github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/permissions/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/permissions", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_Permissions": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 8, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Ref(ptr + 4, undefined); 14 } else { 15 A.store.Bool(ptr + 8, true); 16 A.store.Ref(ptr + 0, x["origins"]); 17 A.store.Ref(ptr + 4, x["permissions"]); 18 } 19 }, 20 "load_Permissions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 21 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 22 23 x["origins"] = A.load.Ref(ptr + 0, undefined); 24 x["permissions"] = A.load.Ref(ptr + 4, undefined); 25 return create === A.H.TRUE ? A.H.push(x) : ref; 26 }, 27 "has_Contains": (): heap.Ref<boolean> => { 28 if (WEBEXT?.permissions && "contains" in WEBEXT?.permissions) { 29 return A.H.TRUE; 30 } 31 return A.H.FALSE; 32 }, 33 "func_Contains": (fn: Pointer): void => { 34 A.store.Ref(fn, WEBEXT.permissions.contains); 35 }, 36 "call_Contains": (retPtr: Pointer, permissions: Pointer): void => { 37 const permissions_ffi = {}; 38 39 permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined); 40 permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined); 41 42 const _ret = WEBEXT.permissions.contains(permissions_ffi); 43 A.store.Ref(retPtr, _ret); 44 }, 45 "try_Contains": (retPtr: Pointer, errPtr: Pointer, permissions: Pointer): heap.Ref<boolean> => { 46 try { 47 const permissions_ffi = {}; 48 49 permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined); 50 permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined); 51 52 const _ret = WEBEXT.permissions.contains(permissions_ffi); 53 A.store.Ref(retPtr, _ret); 54 return A.H.TRUE; 55 } catch (err: any) { 56 A.store.Ref(errPtr, err); 57 return A.H.FALSE; 58 } 59 }, 60 "has_GetAll": (): heap.Ref<boolean> => { 61 if (WEBEXT?.permissions && "getAll" in WEBEXT?.permissions) { 62 return A.H.TRUE; 63 } 64 return A.H.FALSE; 65 }, 66 "func_GetAll": (fn: Pointer): void => { 67 A.store.Ref(fn, WEBEXT.permissions.getAll); 68 }, 69 "call_GetAll": (retPtr: Pointer): void => { 70 const _ret = WEBEXT.permissions.getAll(); 71 A.store.Ref(retPtr, _ret); 72 }, 73 "try_GetAll": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 74 try { 75 const _ret = WEBEXT.permissions.getAll(); 76 A.store.Ref(retPtr, _ret); 77 return A.H.TRUE; 78 } catch (err: any) { 79 A.store.Ref(errPtr, err); 80 return A.H.FALSE; 81 } 82 }, 83 "has_OnAdded": (): heap.Ref<boolean> => { 84 if (WEBEXT?.permissions?.onAdded && "addListener" in WEBEXT?.permissions?.onAdded) { 85 return A.H.TRUE; 86 } 87 return A.H.FALSE; 88 }, 89 "func_OnAdded": (fn: Pointer): void => { 90 A.store.Ref(fn, WEBEXT.permissions.onAdded.addListener); 91 }, 92 "call_OnAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 93 const _ret = WEBEXT.permissions.onAdded.addListener(A.H.get<object>(callback)); 94 }, 95 "try_OnAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 96 try { 97 const _ret = WEBEXT.permissions.onAdded.addListener(A.H.get<object>(callback)); 98 return A.H.TRUE; 99 } catch (err: any) { 100 A.store.Ref(errPtr, err); 101 return A.H.FALSE; 102 } 103 }, 104 "has_OffAdded": (): heap.Ref<boolean> => { 105 if (WEBEXT?.permissions?.onAdded && "removeListener" in WEBEXT?.permissions?.onAdded) { 106 return A.H.TRUE; 107 } 108 return A.H.FALSE; 109 }, 110 "func_OffAdded": (fn: Pointer): void => { 111 A.store.Ref(fn, WEBEXT.permissions.onAdded.removeListener); 112 }, 113 "call_OffAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 114 const _ret = WEBEXT.permissions.onAdded.removeListener(A.H.get<object>(callback)); 115 }, 116 "try_OffAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 117 try { 118 const _ret = WEBEXT.permissions.onAdded.removeListener(A.H.get<object>(callback)); 119 return A.H.TRUE; 120 } catch (err: any) { 121 A.store.Ref(errPtr, err); 122 return A.H.FALSE; 123 } 124 }, 125 "has_HasOnAdded": (): heap.Ref<boolean> => { 126 if (WEBEXT?.permissions?.onAdded && "hasListener" in WEBEXT?.permissions?.onAdded) { 127 return A.H.TRUE; 128 } 129 return A.H.FALSE; 130 }, 131 "func_HasOnAdded": (fn: Pointer): void => { 132 A.store.Ref(fn, WEBEXT.permissions.onAdded.hasListener); 133 }, 134 "call_HasOnAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => { 135 const _ret = WEBEXT.permissions.onAdded.hasListener(A.H.get<object>(callback)); 136 A.store.Bool(retPtr, _ret); 137 }, 138 "try_HasOnAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 139 try { 140 const _ret = WEBEXT.permissions.onAdded.hasListener(A.H.get<object>(callback)); 141 A.store.Bool(retPtr, _ret); 142 return A.H.TRUE; 143 } catch (err: any) { 144 A.store.Ref(errPtr, err); 145 return A.H.FALSE; 146 } 147 }, 148 "has_OnRemoved": (): heap.Ref<boolean> => { 149 if (WEBEXT?.permissions?.onRemoved && "addListener" in WEBEXT?.permissions?.onRemoved) { 150 return A.H.TRUE; 151 } 152 return A.H.FALSE; 153 }, 154 "func_OnRemoved": (fn: Pointer): void => { 155 A.store.Ref(fn, WEBEXT.permissions.onRemoved.addListener); 156 }, 157 "call_OnRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 158 const _ret = WEBEXT.permissions.onRemoved.addListener(A.H.get<object>(callback)); 159 }, 160 "try_OnRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 161 try { 162 const _ret = WEBEXT.permissions.onRemoved.addListener(A.H.get<object>(callback)); 163 return A.H.TRUE; 164 } catch (err: any) { 165 A.store.Ref(errPtr, err); 166 return A.H.FALSE; 167 } 168 }, 169 "has_OffRemoved": (): heap.Ref<boolean> => { 170 if (WEBEXT?.permissions?.onRemoved && "removeListener" in WEBEXT?.permissions?.onRemoved) { 171 return A.H.TRUE; 172 } 173 return A.H.FALSE; 174 }, 175 "func_OffRemoved": (fn: Pointer): void => { 176 A.store.Ref(fn, WEBEXT.permissions.onRemoved.removeListener); 177 }, 178 "call_OffRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 179 const _ret = WEBEXT.permissions.onRemoved.removeListener(A.H.get<object>(callback)); 180 }, 181 "try_OffRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 182 try { 183 const _ret = WEBEXT.permissions.onRemoved.removeListener(A.H.get<object>(callback)); 184 return A.H.TRUE; 185 } catch (err: any) { 186 A.store.Ref(errPtr, err); 187 return A.H.FALSE; 188 } 189 }, 190 "has_HasOnRemoved": (): heap.Ref<boolean> => { 191 if (WEBEXT?.permissions?.onRemoved && "hasListener" in WEBEXT?.permissions?.onRemoved) { 192 return A.H.TRUE; 193 } 194 return A.H.FALSE; 195 }, 196 "func_HasOnRemoved": (fn: Pointer): void => { 197 A.store.Ref(fn, WEBEXT.permissions.onRemoved.hasListener); 198 }, 199 "call_HasOnRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => { 200 const _ret = WEBEXT.permissions.onRemoved.hasListener(A.H.get<object>(callback)); 201 A.store.Bool(retPtr, _ret); 202 }, 203 "try_HasOnRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 204 try { 205 const _ret = WEBEXT.permissions.onRemoved.hasListener(A.H.get<object>(callback)); 206 A.store.Bool(retPtr, _ret); 207 return A.H.TRUE; 208 } catch (err: any) { 209 A.store.Ref(errPtr, err); 210 return A.H.FALSE; 211 } 212 }, 213 "has_Remove": (): heap.Ref<boolean> => { 214 if (WEBEXT?.permissions && "remove" in WEBEXT?.permissions) { 215 return A.H.TRUE; 216 } 217 return A.H.FALSE; 218 }, 219 "func_Remove": (fn: Pointer): void => { 220 A.store.Ref(fn, WEBEXT.permissions.remove); 221 }, 222 "call_Remove": (retPtr: Pointer, permissions: Pointer): void => { 223 const permissions_ffi = {}; 224 225 permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined); 226 permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined); 227 228 const _ret = WEBEXT.permissions.remove(permissions_ffi); 229 A.store.Ref(retPtr, _ret); 230 }, 231 "try_Remove": (retPtr: Pointer, errPtr: Pointer, permissions: Pointer): heap.Ref<boolean> => { 232 try { 233 const permissions_ffi = {}; 234 235 permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined); 236 permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined); 237 238 const _ret = WEBEXT.permissions.remove(permissions_ffi); 239 A.store.Ref(retPtr, _ret); 240 return A.H.TRUE; 241 } catch (err: any) { 242 A.store.Ref(errPtr, err); 243 return A.H.FALSE; 244 } 245 }, 246 "has_Request": (): heap.Ref<boolean> => { 247 if (WEBEXT?.permissions && "request" in WEBEXT?.permissions) { 248 return A.H.TRUE; 249 } 250 return A.H.FALSE; 251 }, 252 "func_Request": (fn: Pointer): void => { 253 A.store.Ref(fn, WEBEXT.permissions.request); 254 }, 255 "call_Request": (retPtr: Pointer, permissions: Pointer): void => { 256 const permissions_ffi = {}; 257 258 permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined); 259 permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined); 260 261 const _ret = WEBEXT.permissions.request(permissions_ffi); 262 A.store.Ref(retPtr, _ret); 263 }, 264 "try_Request": (retPtr: Pointer, errPtr: Pointer, permissions: Pointer): heap.Ref<boolean> => { 265 try { 266 const permissions_ffi = {}; 267 268 permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined); 269 permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined); 270 271 const _ret = WEBEXT.permissions.request(permissions_ffi); 272 A.store.Ref(retPtr, _ret); 273 return A.H.TRUE; 274 } catch (err: any) { 275 A.store.Ref(errPtr, err); 276 return A.H.FALSE; 277 } 278 }, 279 }; 280 });