github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/debugger/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/debugger", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_Debuggee": (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 + 21, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Bool(ptr + 20, false); 14 A.store.Int64(ptr + 8, 0); 15 A.store.Ref(ptr + 16, undefined); 16 } else { 17 A.store.Bool(ptr + 21, true); 18 A.store.Ref(ptr + 0, x["extensionId"]); 19 A.store.Bool(ptr + 20, "tabId" in x ? true : false); 20 A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 21 A.store.Ref(ptr + 16, x["targetId"]); 22 } 23 }, 24 "load_Debuggee": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 25 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 26 27 x["extensionId"] = A.load.Ref(ptr + 0, undefined); 28 if (A.load.Bool(ptr + 20)) { 29 x["tabId"] = A.load.Int64(ptr + 8); 30 } else { 31 delete x["tabId"]; 32 } 33 x["targetId"] = A.load.Ref(ptr + 16, undefined); 34 return create === A.H.TRUE ? A.H.push(x) : ref; 35 }, 36 "constof_DetachReason": (ref: heap.Ref<string>): number => { 37 const idx = ["target_closed", "canceled_by_user"].indexOf(A.H.get(ref)); 38 return idx < 0 ? 0 : idx + 1; 39 }, 40 "constof_TargetInfoType": (ref: heap.Ref<string>): number => { 41 const idx = ["page", "background_page", "worker", "other"].indexOf(A.H.get(ref)); 42 return idx < 0 ? 0 : idx + 1; 43 }, 44 45 "store_TargetInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 46 const x = A.H.get<any>(ref); 47 48 if (typeof x === "undefined") { 49 A.store.Bool(ptr + 37, false); 50 A.store.Bool(ptr + 0, false); 51 A.store.Ref(ptr + 4, undefined); 52 A.store.Ref(ptr + 8, undefined); 53 A.store.Ref(ptr + 12, undefined); 54 A.store.Bool(ptr + 36, false); 55 A.store.Int64(ptr + 16, 0); 56 A.store.Ref(ptr + 24, undefined); 57 A.store.Enum(ptr + 28, -1); 58 A.store.Ref(ptr + 32, undefined); 59 } else { 60 A.store.Bool(ptr + 37, true); 61 A.store.Bool(ptr + 0, x["attached"] ? true : false); 62 A.store.Ref(ptr + 4, x["extensionId"]); 63 A.store.Ref(ptr + 8, x["faviconUrl"]); 64 A.store.Ref(ptr + 12, x["id"]); 65 A.store.Bool(ptr + 36, "tabId" in x ? true : false); 66 A.store.Int64(ptr + 16, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 67 A.store.Ref(ptr + 24, x["title"]); 68 A.store.Enum(ptr + 28, ["page", "background_page", "worker", "other"].indexOf(x["type"] as string)); 69 A.store.Ref(ptr + 32, x["url"]); 70 } 71 }, 72 "load_TargetInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 73 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 74 75 x["attached"] = A.load.Bool(ptr + 0); 76 x["extensionId"] = A.load.Ref(ptr + 4, undefined); 77 x["faviconUrl"] = A.load.Ref(ptr + 8, undefined); 78 x["id"] = A.load.Ref(ptr + 12, undefined); 79 if (A.load.Bool(ptr + 36)) { 80 x["tabId"] = A.load.Int64(ptr + 16); 81 } else { 82 delete x["tabId"]; 83 } 84 x["title"] = A.load.Ref(ptr + 24, undefined); 85 x["type"] = A.load.Enum(ptr + 28, ["page", "background_page", "worker", "other"]); 86 x["url"] = A.load.Ref(ptr + 32, undefined); 87 return create === A.H.TRUE ? A.H.push(x) : ref; 88 }, 89 "has_Attach": (): heap.Ref<boolean> => { 90 if (WEBEXT?.debugger && "attach" in WEBEXT?.debugger) { 91 return A.H.TRUE; 92 } 93 return A.H.FALSE; 94 }, 95 "func_Attach": (fn: Pointer): void => { 96 A.store.Ref(fn, WEBEXT.debugger.attach); 97 }, 98 "call_Attach": (retPtr: Pointer, target: Pointer, requiredVersion: heap.Ref<object>): void => { 99 const target_ffi = {}; 100 101 target_ffi["extensionId"] = A.load.Ref(target + 0, undefined); 102 if (A.load.Bool(target + 20)) { 103 target_ffi["tabId"] = A.load.Int64(target + 8); 104 } 105 target_ffi["targetId"] = A.load.Ref(target + 16, undefined); 106 107 const _ret = WEBEXT.debugger.attach(target_ffi, A.H.get<object>(requiredVersion)); 108 A.store.Ref(retPtr, _ret); 109 }, 110 "try_Attach": ( 111 retPtr: Pointer, 112 errPtr: Pointer, 113 target: Pointer, 114 requiredVersion: heap.Ref<object> 115 ): heap.Ref<boolean> => { 116 try { 117 const target_ffi = {}; 118 119 target_ffi["extensionId"] = A.load.Ref(target + 0, undefined); 120 if (A.load.Bool(target + 20)) { 121 target_ffi["tabId"] = A.load.Int64(target + 8); 122 } 123 target_ffi["targetId"] = A.load.Ref(target + 16, undefined); 124 125 const _ret = WEBEXT.debugger.attach(target_ffi, A.H.get<object>(requiredVersion)); 126 A.store.Ref(retPtr, _ret); 127 return A.H.TRUE; 128 } catch (err: any) { 129 A.store.Ref(errPtr, err); 130 return A.H.FALSE; 131 } 132 }, 133 "has_Detach": (): heap.Ref<boolean> => { 134 if (WEBEXT?.debugger && "detach" in WEBEXT?.debugger) { 135 return A.H.TRUE; 136 } 137 return A.H.FALSE; 138 }, 139 "func_Detach": (fn: Pointer): void => { 140 A.store.Ref(fn, WEBEXT.debugger.detach); 141 }, 142 "call_Detach": (retPtr: Pointer, target: Pointer): void => { 143 const target_ffi = {}; 144 145 target_ffi["extensionId"] = A.load.Ref(target + 0, undefined); 146 if (A.load.Bool(target + 20)) { 147 target_ffi["tabId"] = A.load.Int64(target + 8); 148 } 149 target_ffi["targetId"] = A.load.Ref(target + 16, undefined); 150 151 const _ret = WEBEXT.debugger.detach(target_ffi); 152 A.store.Ref(retPtr, _ret); 153 }, 154 "try_Detach": (retPtr: Pointer, errPtr: Pointer, target: Pointer): heap.Ref<boolean> => { 155 try { 156 const target_ffi = {}; 157 158 target_ffi["extensionId"] = A.load.Ref(target + 0, undefined); 159 if (A.load.Bool(target + 20)) { 160 target_ffi["tabId"] = A.load.Int64(target + 8); 161 } 162 target_ffi["targetId"] = A.load.Ref(target + 16, undefined); 163 164 const _ret = WEBEXT.debugger.detach(target_ffi); 165 A.store.Ref(retPtr, _ret); 166 return A.H.TRUE; 167 } catch (err: any) { 168 A.store.Ref(errPtr, err); 169 return A.H.FALSE; 170 } 171 }, 172 "has_GetTargets": (): heap.Ref<boolean> => { 173 if (WEBEXT?.debugger && "getTargets" in WEBEXT?.debugger) { 174 return A.H.TRUE; 175 } 176 return A.H.FALSE; 177 }, 178 "func_GetTargets": (fn: Pointer): void => { 179 A.store.Ref(fn, WEBEXT.debugger.getTargets); 180 }, 181 "call_GetTargets": (retPtr: Pointer): void => { 182 const _ret = WEBEXT.debugger.getTargets(); 183 A.store.Ref(retPtr, _ret); 184 }, 185 "try_GetTargets": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 186 try { 187 const _ret = WEBEXT.debugger.getTargets(); 188 A.store.Ref(retPtr, _ret); 189 return A.H.TRUE; 190 } catch (err: any) { 191 A.store.Ref(errPtr, err); 192 return A.H.FALSE; 193 } 194 }, 195 "has_OnDetach": (): heap.Ref<boolean> => { 196 if (WEBEXT?.debugger?.onDetach && "addListener" in WEBEXT?.debugger?.onDetach) { 197 return A.H.TRUE; 198 } 199 return A.H.FALSE; 200 }, 201 "func_OnDetach": (fn: Pointer): void => { 202 A.store.Ref(fn, WEBEXT.debugger.onDetach.addListener); 203 }, 204 "call_OnDetach": (retPtr: Pointer, callback: heap.Ref<object>): void => { 205 const _ret = WEBEXT.debugger.onDetach.addListener(A.H.get<object>(callback)); 206 }, 207 "try_OnDetach": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 208 try { 209 const _ret = WEBEXT.debugger.onDetach.addListener(A.H.get<object>(callback)); 210 return A.H.TRUE; 211 } catch (err: any) { 212 A.store.Ref(errPtr, err); 213 return A.H.FALSE; 214 } 215 }, 216 "has_OffDetach": (): heap.Ref<boolean> => { 217 if (WEBEXT?.debugger?.onDetach && "removeListener" in WEBEXT?.debugger?.onDetach) { 218 return A.H.TRUE; 219 } 220 return A.H.FALSE; 221 }, 222 "func_OffDetach": (fn: Pointer): void => { 223 A.store.Ref(fn, WEBEXT.debugger.onDetach.removeListener); 224 }, 225 "call_OffDetach": (retPtr: Pointer, callback: heap.Ref<object>): void => { 226 const _ret = WEBEXT.debugger.onDetach.removeListener(A.H.get<object>(callback)); 227 }, 228 "try_OffDetach": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 229 try { 230 const _ret = WEBEXT.debugger.onDetach.removeListener(A.H.get<object>(callback)); 231 return A.H.TRUE; 232 } catch (err: any) { 233 A.store.Ref(errPtr, err); 234 return A.H.FALSE; 235 } 236 }, 237 "has_HasOnDetach": (): heap.Ref<boolean> => { 238 if (WEBEXT?.debugger?.onDetach && "hasListener" in WEBEXT?.debugger?.onDetach) { 239 return A.H.TRUE; 240 } 241 return A.H.FALSE; 242 }, 243 "func_HasOnDetach": (fn: Pointer): void => { 244 A.store.Ref(fn, WEBEXT.debugger.onDetach.hasListener); 245 }, 246 "call_HasOnDetach": (retPtr: Pointer, callback: heap.Ref<object>): void => { 247 const _ret = WEBEXT.debugger.onDetach.hasListener(A.H.get<object>(callback)); 248 A.store.Bool(retPtr, _ret); 249 }, 250 "try_HasOnDetach": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 251 try { 252 const _ret = WEBEXT.debugger.onDetach.hasListener(A.H.get<object>(callback)); 253 A.store.Bool(retPtr, _ret); 254 return A.H.TRUE; 255 } catch (err: any) { 256 A.store.Ref(errPtr, err); 257 return A.H.FALSE; 258 } 259 }, 260 "has_OnEvent": (): heap.Ref<boolean> => { 261 if (WEBEXT?.debugger?.onEvent && "addListener" in WEBEXT?.debugger?.onEvent) { 262 return A.H.TRUE; 263 } 264 return A.H.FALSE; 265 }, 266 "func_OnEvent": (fn: Pointer): void => { 267 A.store.Ref(fn, WEBEXT.debugger.onEvent.addListener); 268 }, 269 "call_OnEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => { 270 const _ret = WEBEXT.debugger.onEvent.addListener(A.H.get<object>(callback)); 271 }, 272 "try_OnEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 273 try { 274 const _ret = WEBEXT.debugger.onEvent.addListener(A.H.get<object>(callback)); 275 return A.H.TRUE; 276 } catch (err: any) { 277 A.store.Ref(errPtr, err); 278 return A.H.FALSE; 279 } 280 }, 281 "has_OffEvent": (): heap.Ref<boolean> => { 282 if (WEBEXT?.debugger?.onEvent && "removeListener" in WEBEXT?.debugger?.onEvent) { 283 return A.H.TRUE; 284 } 285 return A.H.FALSE; 286 }, 287 "func_OffEvent": (fn: Pointer): void => { 288 A.store.Ref(fn, WEBEXT.debugger.onEvent.removeListener); 289 }, 290 "call_OffEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => { 291 const _ret = WEBEXT.debugger.onEvent.removeListener(A.H.get<object>(callback)); 292 }, 293 "try_OffEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 294 try { 295 const _ret = WEBEXT.debugger.onEvent.removeListener(A.H.get<object>(callback)); 296 return A.H.TRUE; 297 } catch (err: any) { 298 A.store.Ref(errPtr, err); 299 return A.H.FALSE; 300 } 301 }, 302 "has_HasOnEvent": (): heap.Ref<boolean> => { 303 if (WEBEXT?.debugger?.onEvent && "hasListener" in WEBEXT?.debugger?.onEvent) { 304 return A.H.TRUE; 305 } 306 return A.H.FALSE; 307 }, 308 "func_HasOnEvent": (fn: Pointer): void => { 309 A.store.Ref(fn, WEBEXT.debugger.onEvent.hasListener); 310 }, 311 "call_HasOnEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => { 312 const _ret = WEBEXT.debugger.onEvent.hasListener(A.H.get<object>(callback)); 313 A.store.Bool(retPtr, _ret); 314 }, 315 "try_HasOnEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 316 try { 317 const _ret = WEBEXT.debugger.onEvent.hasListener(A.H.get<object>(callback)); 318 A.store.Bool(retPtr, _ret); 319 return A.H.TRUE; 320 } catch (err: any) { 321 A.store.Ref(errPtr, err); 322 return A.H.FALSE; 323 } 324 }, 325 "has_SendCommand": (): heap.Ref<boolean> => { 326 if (WEBEXT?.debugger && "sendCommand" in WEBEXT?.debugger) { 327 return A.H.TRUE; 328 } 329 return A.H.FALSE; 330 }, 331 "func_SendCommand": (fn: Pointer): void => { 332 A.store.Ref(fn, WEBEXT.debugger.sendCommand); 333 }, 334 "call_SendCommand": ( 335 retPtr: Pointer, 336 target: Pointer, 337 method: heap.Ref<object>, 338 commandParams: heap.Ref<object> 339 ): void => { 340 const target_ffi = {}; 341 342 target_ffi["extensionId"] = A.load.Ref(target + 0, undefined); 343 if (A.load.Bool(target + 20)) { 344 target_ffi["tabId"] = A.load.Int64(target + 8); 345 } 346 target_ffi["targetId"] = A.load.Ref(target + 16, undefined); 347 348 const _ret = WEBEXT.debugger.sendCommand(target_ffi, A.H.get<object>(method), A.H.get<object>(commandParams)); 349 A.store.Ref(retPtr, _ret); 350 }, 351 "try_SendCommand": ( 352 retPtr: Pointer, 353 errPtr: Pointer, 354 target: Pointer, 355 method: heap.Ref<object>, 356 commandParams: heap.Ref<object> 357 ): heap.Ref<boolean> => { 358 try { 359 const target_ffi = {}; 360 361 target_ffi["extensionId"] = A.load.Ref(target + 0, undefined); 362 if (A.load.Bool(target + 20)) { 363 target_ffi["tabId"] = A.load.Int64(target + 8); 364 } 365 target_ffi["targetId"] = A.load.Ref(target + 16, undefined); 366 367 const _ret = WEBEXT.debugger.sendCommand(target_ffi, A.H.get<object>(method), A.H.get<object>(commandParams)); 368 A.store.Ref(retPtr, _ret); 369 return A.H.TRUE; 370 } catch (err: any) { 371 A.store.Ref(errPtr, err); 372 return A.H.FALSE; 373 } 374 }, 375 }; 376 });