github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/app/runtime/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/app/runtime", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_ActionType": (ref: heap.Ref<string>): number => { 8 const idx = ["new_note"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 12 "store_ActionData": (ptr: Pointer, ref: heap.Ref<any>) => { 13 const x = A.H.get<any>(ref); 14 15 if (typeof x === "undefined") { 16 A.store.Bool(ptr + 8, false); 17 A.store.Enum(ptr + 0, -1); 18 A.store.Bool(ptr + 6, false); 19 A.store.Bool(ptr + 4, false); 20 A.store.Bool(ptr + 7, false); 21 A.store.Bool(ptr + 5, false); 22 } else { 23 A.store.Bool(ptr + 8, true); 24 A.store.Enum(ptr + 0, ["new_note"].indexOf(x["actionType"] as string)); 25 A.store.Bool(ptr + 6, "isLockScreenAction" in x ? true : false); 26 A.store.Bool(ptr + 4, x["isLockScreenAction"] ? true : false); 27 A.store.Bool(ptr + 7, "restoreLastActionState" in x ? true : false); 28 A.store.Bool(ptr + 5, x["restoreLastActionState"] ? true : false); 29 } 30 }, 31 "load_ActionData": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 32 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 33 34 x["actionType"] = A.load.Enum(ptr + 0, ["new_note"]); 35 if (A.load.Bool(ptr + 6)) { 36 x["isLockScreenAction"] = A.load.Bool(ptr + 4); 37 } else { 38 delete x["isLockScreenAction"]; 39 } 40 if (A.load.Bool(ptr + 7)) { 41 x["restoreLastActionState"] = A.load.Bool(ptr + 5); 42 } else { 43 delete x["restoreLastActionState"]; 44 } 45 return create === A.H.TRUE ? A.H.push(x) : ref; 46 }, 47 48 "has_EmbedRequest_Allow": (self: heap.Ref<any>): heap.Ref<boolean> => { 49 const obj = A.H.get<object>(self); 50 if (obj && "allow" in obj) { 51 return A.H.TRUE; 52 } 53 return A.H.FALSE; 54 }, 55 "func_EmbedRequest_Allow": (self: heap.Ref<any>, fn: Pointer): void => { 56 A.store.Ref(fn, A.H.get<any>(self).allow); 57 }, 58 59 "call_EmbedRequest_Allow": (self: heap.Ref<object>, retPtr: Pointer, url: heap.Ref<object>): void => { 60 const thiz = A.H.get<any>(self); 61 62 const _ret = thiz.allow(A.H.get<object>(url)); 63 }, 64 "try_EmbedRequest_Allow": ( 65 self: heap.Ref<object>, 66 retPtr: Pointer, 67 errPtr: Pointer, 68 url: heap.Ref<object> 69 ): heap.Ref<boolean> => { 70 try { 71 const thiz = A.H.get<any>(self); 72 73 const _ret = thiz.allow(A.H.get<object>(url)); 74 return A.H.TRUE; 75 } catch (err: any) { 76 A.store.Ref(errPtr, err); 77 return A.H.FALSE; 78 } 79 }, 80 "has_EmbedRequest_Deny": (self: heap.Ref<any>): heap.Ref<boolean> => { 81 const obj = A.H.get<object>(self); 82 if (obj && "deny" in obj) { 83 return A.H.TRUE; 84 } 85 return A.H.FALSE; 86 }, 87 "func_EmbedRequest_Deny": (self: heap.Ref<any>, fn: Pointer): void => { 88 A.store.Ref(fn, A.H.get<any>(self).deny); 89 }, 90 91 "call_EmbedRequest_Deny": (self: heap.Ref<object>, retPtr: Pointer): void => { 92 const thiz = A.H.get<any>(self); 93 94 const _ret = thiz.deny(); 95 }, 96 "try_EmbedRequest_Deny": (self: heap.Ref<object>, retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 97 try { 98 const thiz = A.H.get<any>(self); 99 100 const _ret = thiz.deny(); 101 return A.H.TRUE; 102 } catch (err: any) { 103 A.store.Ref(errPtr, err); 104 return A.H.FALSE; 105 } 106 }, 107 "get_EmbedRequest_EmbedderId": (self: heap.Ref<any>, retPtr: Pointer): heap.Ref<boolean> => { 108 const thiz = A.H.get<object>(self); 109 if (thiz && "embedderId" in thiz) { 110 const val = thiz.embedderId; 111 A.store.Ref(retPtr, val); 112 return A.H.TRUE; 113 } 114 115 return A.H.FALSE; 116 }, 117 "set_EmbedRequest_EmbedderId": (self: heap.Ref<object>, val: heap.Ref<object>): heap.Ref<boolean> => { 118 const thiz = A.H.get<object>(self); 119 120 return Reflect.set(thiz, "embedderId", A.H.get<object>(val), thiz) ? A.H.TRUE : A.H.FALSE; 121 }, 122 "get_EmbedRequest_Data": (self: heap.Ref<any>, retPtr: Pointer): heap.Ref<boolean> => { 123 const thiz = A.H.get<object>(self); 124 if (thiz && "data" in thiz) { 125 const val = thiz.data; 126 A.store.Ref(retPtr, val); 127 return A.H.TRUE; 128 } 129 130 return A.H.FALSE; 131 }, 132 "set_EmbedRequest_Data": (self: heap.Ref<object>, val: heap.Ref<object>): heap.Ref<boolean> => { 133 const thiz = A.H.get<object>(self); 134 135 return Reflect.set(thiz, "data", A.H.get<object>(val), thiz) ? A.H.TRUE : A.H.FALSE; 136 }, 137 138 "store_LaunchItem": (ptr: Pointer, ref: heap.Ref<any>) => { 139 const x = A.H.get<any>(ref); 140 141 if (typeof x === "undefined") { 142 A.store.Bool(ptr + 8, false); 143 A.store.Ref(ptr + 0, undefined); 144 A.store.Ref(ptr + 4, undefined); 145 } else { 146 A.store.Bool(ptr + 8, true); 147 A.store.Ref(ptr + 0, x["entry"]); 148 A.store.Ref(ptr + 4, x["type"]); 149 } 150 }, 151 "load_LaunchItem": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 152 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 153 154 x["entry"] = A.load.Ref(ptr + 0, undefined); 155 x["type"] = A.load.Ref(ptr + 4, undefined); 156 return create === A.H.TRUE ? A.H.push(x) : ref; 157 }, 158 "constof_LaunchSource": (ref: heap.Ref<string>): number => { 159 const idx = [ 160 "untracked", 161 "app_launcher", 162 "new_tab_page", 163 "reload", 164 "restart", 165 "load_and_launch", 166 "command_line", 167 "file_handler", 168 "url_handler", 169 "system_tray", 170 "about_page", 171 "keyboard", 172 "extensions_page", 173 "management_api", 174 "ephemeral_app", 175 "background", 176 "kiosk", 177 "chrome_internal", 178 "test", 179 "installed_notification", 180 "context_menu", 181 "arc", 182 "intent_url", 183 "app_home_page", 184 ].indexOf(A.H.get(ref)); 185 return idx < 0 ? 0 : idx + 1; 186 }, 187 188 "store_LaunchData": (ptr: Pointer, ref: heap.Ref<any>) => { 189 const x = A.H.get<any>(ref); 190 191 if (typeof x === "undefined") { 192 A.store.Bool(ptr + 36, false); 193 A.store.Ref(ptr + 0, undefined); 194 A.store.Ref(ptr + 4, undefined); 195 A.store.Ref(ptr + 8, undefined); 196 A.store.Ref(ptr + 12, undefined); 197 A.store.Bool(ptr + 33, false); 198 A.store.Bool(ptr + 16, false); 199 A.store.Bool(ptr + 34, false); 200 A.store.Bool(ptr + 17, false); 201 A.store.Bool(ptr + 35, false); 202 A.store.Bool(ptr + 18, false); 203 A.store.Enum(ptr + 20, -1); 204 205 A.store.Bool(ptr + 24 + 8, false); 206 A.store.Enum(ptr + 24 + 0, -1); 207 A.store.Bool(ptr + 24 + 6, false); 208 A.store.Bool(ptr + 24 + 4, false); 209 A.store.Bool(ptr + 24 + 7, false); 210 A.store.Bool(ptr + 24 + 5, false); 211 } else { 212 A.store.Bool(ptr + 36, true); 213 A.store.Ref(ptr + 0, x["id"]); 214 A.store.Ref(ptr + 4, x["items"]); 215 A.store.Ref(ptr + 8, x["url"]); 216 A.store.Ref(ptr + 12, x["referrerUrl"]); 217 A.store.Bool(ptr + 33, "isDemoSession" in x ? true : false); 218 A.store.Bool(ptr + 16, x["isDemoSession"] ? true : false); 219 A.store.Bool(ptr + 34, "isKioskSession" in x ? true : false); 220 A.store.Bool(ptr + 17, x["isKioskSession"] ? true : false); 221 A.store.Bool(ptr + 35, "isPublicSession" in x ? true : false); 222 A.store.Bool(ptr + 18, x["isPublicSession"] ? true : false); 223 A.store.Enum( 224 ptr + 20, 225 [ 226 "untracked", 227 "app_launcher", 228 "new_tab_page", 229 "reload", 230 "restart", 231 "load_and_launch", 232 "command_line", 233 "file_handler", 234 "url_handler", 235 "system_tray", 236 "about_page", 237 "keyboard", 238 "extensions_page", 239 "management_api", 240 "ephemeral_app", 241 "background", 242 "kiosk", 243 "chrome_internal", 244 "test", 245 "installed_notification", 246 "context_menu", 247 "arc", 248 "intent_url", 249 "app_home_page", 250 ].indexOf(x["source"] as string) 251 ); 252 253 if (typeof x["actionData"] === "undefined") { 254 A.store.Bool(ptr + 24 + 8, false); 255 A.store.Enum(ptr + 24 + 0, -1); 256 A.store.Bool(ptr + 24 + 6, false); 257 A.store.Bool(ptr + 24 + 4, false); 258 A.store.Bool(ptr + 24 + 7, false); 259 A.store.Bool(ptr + 24 + 5, false); 260 } else { 261 A.store.Bool(ptr + 24 + 8, true); 262 A.store.Enum(ptr + 24 + 0, ["new_note"].indexOf(x["actionData"]["actionType"] as string)); 263 A.store.Bool(ptr + 24 + 6, "isLockScreenAction" in x["actionData"] ? true : false); 264 A.store.Bool(ptr + 24 + 4, x["actionData"]["isLockScreenAction"] ? true : false); 265 A.store.Bool(ptr + 24 + 7, "restoreLastActionState" in x["actionData"] ? true : false); 266 A.store.Bool(ptr + 24 + 5, x["actionData"]["restoreLastActionState"] ? true : false); 267 } 268 } 269 }, 270 "load_LaunchData": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 271 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 272 273 x["id"] = A.load.Ref(ptr + 0, undefined); 274 x["items"] = A.load.Ref(ptr + 4, undefined); 275 x["url"] = A.load.Ref(ptr + 8, undefined); 276 x["referrerUrl"] = A.load.Ref(ptr + 12, undefined); 277 if (A.load.Bool(ptr + 33)) { 278 x["isDemoSession"] = A.load.Bool(ptr + 16); 279 } else { 280 delete x["isDemoSession"]; 281 } 282 if (A.load.Bool(ptr + 34)) { 283 x["isKioskSession"] = A.load.Bool(ptr + 17); 284 } else { 285 delete x["isKioskSession"]; 286 } 287 if (A.load.Bool(ptr + 35)) { 288 x["isPublicSession"] = A.load.Bool(ptr + 18); 289 } else { 290 delete x["isPublicSession"]; 291 } 292 x["source"] = A.load.Enum(ptr + 20, [ 293 "untracked", 294 "app_launcher", 295 "new_tab_page", 296 "reload", 297 "restart", 298 "load_and_launch", 299 "command_line", 300 "file_handler", 301 "url_handler", 302 "system_tray", 303 "about_page", 304 "keyboard", 305 "extensions_page", 306 "management_api", 307 "ephemeral_app", 308 "background", 309 "kiosk", 310 "chrome_internal", 311 "test", 312 "installed_notification", 313 "context_menu", 314 "arc", 315 "intent_url", 316 "app_home_page", 317 ]); 318 if (A.load.Bool(ptr + 24 + 8)) { 319 x["actionData"] = {}; 320 x["actionData"]["actionType"] = A.load.Enum(ptr + 24 + 0, ["new_note"]); 321 if (A.load.Bool(ptr + 24 + 6)) { 322 x["actionData"]["isLockScreenAction"] = A.load.Bool(ptr + 24 + 4); 323 } else { 324 delete x["actionData"]["isLockScreenAction"]; 325 } 326 if (A.load.Bool(ptr + 24 + 7)) { 327 x["actionData"]["restoreLastActionState"] = A.load.Bool(ptr + 24 + 5); 328 } else { 329 delete x["actionData"]["restoreLastActionState"]; 330 } 331 } else { 332 delete x["actionData"]; 333 } 334 return create === A.H.TRUE ? A.H.push(x) : ref; 335 }, 336 "has_OnEmbedRequested": (): heap.Ref<boolean> => { 337 if (WEBEXT?.app?.runtime?.onEmbedRequested && "addListener" in WEBEXT?.app?.runtime?.onEmbedRequested) { 338 return A.H.TRUE; 339 } 340 return A.H.FALSE; 341 }, 342 "func_OnEmbedRequested": (fn: Pointer): void => { 343 A.store.Ref(fn, WEBEXT.app.runtime.onEmbedRequested.addListener); 344 }, 345 "call_OnEmbedRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 346 const _ret = WEBEXT.app.runtime.onEmbedRequested.addListener(A.H.get<object>(callback)); 347 }, 348 "try_OnEmbedRequested": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 349 try { 350 const _ret = WEBEXT.app.runtime.onEmbedRequested.addListener(A.H.get<object>(callback)); 351 return A.H.TRUE; 352 } catch (err: any) { 353 A.store.Ref(errPtr, err); 354 return A.H.FALSE; 355 } 356 }, 357 "has_OffEmbedRequested": (): heap.Ref<boolean> => { 358 if (WEBEXT?.app?.runtime?.onEmbedRequested && "removeListener" in WEBEXT?.app?.runtime?.onEmbedRequested) { 359 return A.H.TRUE; 360 } 361 return A.H.FALSE; 362 }, 363 "func_OffEmbedRequested": (fn: Pointer): void => { 364 A.store.Ref(fn, WEBEXT.app.runtime.onEmbedRequested.removeListener); 365 }, 366 "call_OffEmbedRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 367 const _ret = WEBEXT.app.runtime.onEmbedRequested.removeListener(A.H.get<object>(callback)); 368 }, 369 "try_OffEmbedRequested": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 370 try { 371 const _ret = WEBEXT.app.runtime.onEmbedRequested.removeListener(A.H.get<object>(callback)); 372 return A.H.TRUE; 373 } catch (err: any) { 374 A.store.Ref(errPtr, err); 375 return A.H.FALSE; 376 } 377 }, 378 "has_HasOnEmbedRequested": (): heap.Ref<boolean> => { 379 if (WEBEXT?.app?.runtime?.onEmbedRequested && "hasListener" in WEBEXT?.app?.runtime?.onEmbedRequested) { 380 return A.H.TRUE; 381 } 382 return A.H.FALSE; 383 }, 384 "func_HasOnEmbedRequested": (fn: Pointer): void => { 385 A.store.Ref(fn, WEBEXT.app.runtime.onEmbedRequested.hasListener); 386 }, 387 "call_HasOnEmbedRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => { 388 const _ret = WEBEXT.app.runtime.onEmbedRequested.hasListener(A.H.get<object>(callback)); 389 A.store.Bool(retPtr, _ret); 390 }, 391 "try_HasOnEmbedRequested": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 392 try { 393 const _ret = WEBEXT.app.runtime.onEmbedRequested.hasListener(A.H.get<object>(callback)); 394 A.store.Bool(retPtr, _ret); 395 return A.H.TRUE; 396 } catch (err: any) { 397 A.store.Ref(errPtr, err); 398 return A.H.FALSE; 399 } 400 }, 401 "has_OnLaunched": (): heap.Ref<boolean> => { 402 if (WEBEXT?.app?.runtime?.onLaunched && "addListener" in WEBEXT?.app?.runtime?.onLaunched) { 403 return A.H.TRUE; 404 } 405 return A.H.FALSE; 406 }, 407 "func_OnLaunched": (fn: Pointer): void => { 408 A.store.Ref(fn, WEBEXT.app.runtime.onLaunched.addListener); 409 }, 410 "call_OnLaunched": (retPtr: Pointer, callback: heap.Ref<object>): void => { 411 const _ret = WEBEXT.app.runtime.onLaunched.addListener(A.H.get<object>(callback)); 412 }, 413 "try_OnLaunched": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 414 try { 415 const _ret = WEBEXT.app.runtime.onLaunched.addListener(A.H.get<object>(callback)); 416 return A.H.TRUE; 417 } catch (err: any) { 418 A.store.Ref(errPtr, err); 419 return A.H.FALSE; 420 } 421 }, 422 "has_OffLaunched": (): heap.Ref<boolean> => { 423 if (WEBEXT?.app?.runtime?.onLaunched && "removeListener" in WEBEXT?.app?.runtime?.onLaunched) { 424 return A.H.TRUE; 425 } 426 return A.H.FALSE; 427 }, 428 "func_OffLaunched": (fn: Pointer): void => { 429 A.store.Ref(fn, WEBEXT.app.runtime.onLaunched.removeListener); 430 }, 431 "call_OffLaunched": (retPtr: Pointer, callback: heap.Ref<object>): void => { 432 const _ret = WEBEXT.app.runtime.onLaunched.removeListener(A.H.get<object>(callback)); 433 }, 434 "try_OffLaunched": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 435 try { 436 const _ret = WEBEXT.app.runtime.onLaunched.removeListener(A.H.get<object>(callback)); 437 return A.H.TRUE; 438 } catch (err: any) { 439 A.store.Ref(errPtr, err); 440 return A.H.FALSE; 441 } 442 }, 443 "has_HasOnLaunched": (): heap.Ref<boolean> => { 444 if (WEBEXT?.app?.runtime?.onLaunched && "hasListener" in WEBEXT?.app?.runtime?.onLaunched) { 445 return A.H.TRUE; 446 } 447 return A.H.FALSE; 448 }, 449 "func_HasOnLaunched": (fn: Pointer): void => { 450 A.store.Ref(fn, WEBEXT.app.runtime.onLaunched.hasListener); 451 }, 452 "call_HasOnLaunched": (retPtr: Pointer, callback: heap.Ref<object>): void => { 453 const _ret = WEBEXT.app.runtime.onLaunched.hasListener(A.H.get<object>(callback)); 454 A.store.Bool(retPtr, _ret); 455 }, 456 "try_HasOnLaunched": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 457 try { 458 const _ret = WEBEXT.app.runtime.onLaunched.hasListener(A.H.get<object>(callback)); 459 A.store.Bool(retPtr, _ret); 460 return A.H.TRUE; 461 } catch (err: any) { 462 A.store.Ref(errPtr, err); 463 return A.H.FALSE; 464 } 465 }, 466 "has_OnRestarted": (): heap.Ref<boolean> => { 467 if (WEBEXT?.app?.runtime?.onRestarted && "addListener" in WEBEXT?.app?.runtime?.onRestarted) { 468 return A.H.TRUE; 469 } 470 return A.H.FALSE; 471 }, 472 "func_OnRestarted": (fn: Pointer): void => { 473 A.store.Ref(fn, WEBEXT.app.runtime.onRestarted.addListener); 474 }, 475 "call_OnRestarted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 476 const _ret = WEBEXT.app.runtime.onRestarted.addListener(A.H.get<object>(callback)); 477 }, 478 "try_OnRestarted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 479 try { 480 const _ret = WEBEXT.app.runtime.onRestarted.addListener(A.H.get<object>(callback)); 481 return A.H.TRUE; 482 } catch (err: any) { 483 A.store.Ref(errPtr, err); 484 return A.H.FALSE; 485 } 486 }, 487 "has_OffRestarted": (): heap.Ref<boolean> => { 488 if (WEBEXT?.app?.runtime?.onRestarted && "removeListener" in WEBEXT?.app?.runtime?.onRestarted) { 489 return A.H.TRUE; 490 } 491 return A.H.FALSE; 492 }, 493 "func_OffRestarted": (fn: Pointer): void => { 494 A.store.Ref(fn, WEBEXT.app.runtime.onRestarted.removeListener); 495 }, 496 "call_OffRestarted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 497 const _ret = WEBEXT.app.runtime.onRestarted.removeListener(A.H.get<object>(callback)); 498 }, 499 "try_OffRestarted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 500 try { 501 const _ret = WEBEXT.app.runtime.onRestarted.removeListener(A.H.get<object>(callback)); 502 return A.H.TRUE; 503 } catch (err: any) { 504 A.store.Ref(errPtr, err); 505 return A.H.FALSE; 506 } 507 }, 508 "has_HasOnRestarted": (): heap.Ref<boolean> => { 509 if (WEBEXT?.app?.runtime?.onRestarted && "hasListener" in WEBEXT?.app?.runtime?.onRestarted) { 510 return A.H.TRUE; 511 } 512 return A.H.FALSE; 513 }, 514 "func_HasOnRestarted": (fn: Pointer): void => { 515 A.store.Ref(fn, WEBEXT.app.runtime.onRestarted.hasListener); 516 }, 517 "call_HasOnRestarted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 518 const _ret = WEBEXT.app.runtime.onRestarted.hasListener(A.H.get<object>(callback)); 519 A.store.Bool(retPtr, _ret); 520 }, 521 "try_HasOnRestarted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 522 try { 523 const _ret = WEBEXT.app.runtime.onRestarted.hasListener(A.H.get<object>(callback)); 524 A.store.Bool(retPtr, _ret); 525 return A.H.TRUE; 526 } catch (err: any) { 527 A.store.Ref(errPtr, err); 528 return A.H.FALSE; 529 } 530 }, 531 }; 532 });