github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/action/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/action", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_OpenPopupOptions": (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 + 9, false); 12 A.store.Bool(ptr + 8, false); 13 A.store.Int64(ptr + 0, 0); 14 } else { 15 A.store.Bool(ptr + 9, true); 16 A.store.Bool(ptr + 8, "windowId" in x ? true : false); 17 A.store.Int64(ptr + 0, x["windowId"] === undefined ? 0 : (x["windowId"] as number)); 18 } 19 }, 20 "load_OpenPopupOptions": (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 if (A.load.Bool(ptr + 8)) { 24 x["windowId"] = A.load.Int64(ptr + 0); 25 } else { 26 delete x["windowId"]; 27 } 28 return create === A.H.TRUE ? A.H.push(x) : ref; 29 }, 30 31 "store_SetBadgeBackgroundColorArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 32 const x = A.H.get<any>(ref); 33 34 if (typeof x === "undefined") { 35 A.store.Bool(ptr + 17, false); 36 A.store.Ref(ptr + 0, undefined); 37 A.store.Bool(ptr + 16, false); 38 A.store.Int64(ptr + 8, 0); 39 } else { 40 A.store.Bool(ptr + 17, true); 41 A.store.Ref(ptr + 0, x["color"]); 42 A.store.Bool(ptr + 16, "tabId" in x ? true : false); 43 A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 44 } 45 }, 46 "load_SetBadgeBackgroundColorArgDetails": ( 47 ptr: Pointer, 48 create: heap.Ref<boolean>, 49 ref: heap.Ref<any> 50 ): heap.Ref<any> => { 51 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 52 53 x["color"] = A.load.Ref(ptr + 0, undefined); 54 if (A.load.Bool(ptr + 16)) { 55 x["tabId"] = A.load.Int64(ptr + 8); 56 } else { 57 delete x["tabId"]; 58 } 59 return create === A.H.TRUE ? A.H.push(x) : ref; 60 }, 61 62 "store_SetBadgeTextArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 63 const x = A.H.get<any>(ref); 64 65 if (typeof x === "undefined") { 66 A.store.Bool(ptr + 13, false); 67 A.store.Bool(ptr + 12, false); 68 A.store.Int64(ptr + 0, 0); 69 A.store.Ref(ptr + 8, undefined); 70 } else { 71 A.store.Bool(ptr + 13, true); 72 A.store.Bool(ptr + 12, "tabId" in x ? true : false); 73 A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 74 A.store.Ref(ptr + 8, x["text"]); 75 } 76 }, 77 "load_SetBadgeTextArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 78 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 79 80 if (A.load.Bool(ptr + 12)) { 81 x["tabId"] = A.load.Int64(ptr + 0); 82 } else { 83 delete x["tabId"]; 84 } 85 x["text"] = A.load.Ref(ptr + 8, undefined); 86 return create === A.H.TRUE ? A.H.push(x) : ref; 87 }, 88 89 "store_SetBadgeTextColorArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 90 const x = A.H.get<any>(ref); 91 92 if (typeof x === "undefined") { 93 A.store.Bool(ptr + 17, false); 94 A.store.Ref(ptr + 0, undefined); 95 A.store.Bool(ptr + 16, false); 96 A.store.Int64(ptr + 8, 0); 97 } else { 98 A.store.Bool(ptr + 17, true); 99 A.store.Ref(ptr + 0, x["color"]); 100 A.store.Bool(ptr + 16, "tabId" in x ? true : false); 101 A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 102 } 103 }, 104 "load_SetBadgeTextColorArgDetails": ( 105 ptr: Pointer, 106 create: heap.Ref<boolean>, 107 ref: heap.Ref<any> 108 ): heap.Ref<any> => { 109 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 110 111 x["color"] = A.load.Ref(ptr + 0, undefined); 112 if (A.load.Bool(ptr + 16)) { 113 x["tabId"] = A.load.Int64(ptr + 8); 114 } else { 115 delete x["tabId"]; 116 } 117 return create === A.H.TRUE ? A.H.push(x) : ref; 118 }, 119 120 "store_SetIconArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 121 const x = A.H.get<any>(ref); 122 123 if (typeof x === "undefined") { 124 A.store.Bool(ptr + 17, false); 125 A.store.Ref(ptr + 0, undefined); 126 A.store.Ref(ptr + 4, undefined); 127 A.store.Bool(ptr + 16, false); 128 A.store.Int64(ptr + 8, 0); 129 } else { 130 A.store.Bool(ptr + 17, true); 131 A.store.Ref(ptr + 0, x["imageData"]); 132 A.store.Ref(ptr + 4, x["path"]); 133 A.store.Bool(ptr + 16, "tabId" in x ? true : false); 134 A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 135 } 136 }, 137 "load_SetIconArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 138 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 139 140 x["imageData"] = A.load.Ref(ptr + 0, undefined); 141 x["path"] = A.load.Ref(ptr + 4, undefined); 142 if (A.load.Bool(ptr + 16)) { 143 x["tabId"] = A.load.Int64(ptr + 8); 144 } else { 145 delete x["tabId"]; 146 } 147 return create === A.H.TRUE ? A.H.push(x) : ref; 148 }, 149 150 "store_SetPopupArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 151 const x = A.H.get<any>(ref); 152 153 if (typeof x === "undefined") { 154 A.store.Bool(ptr + 17, false); 155 A.store.Ref(ptr + 0, undefined); 156 A.store.Bool(ptr + 16, false); 157 A.store.Int64(ptr + 8, 0); 158 } else { 159 A.store.Bool(ptr + 17, true); 160 A.store.Ref(ptr + 0, x["popup"]); 161 A.store.Bool(ptr + 16, "tabId" in x ? true : false); 162 A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 163 } 164 }, 165 "load_SetPopupArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 166 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 167 168 x["popup"] = A.load.Ref(ptr + 0, undefined); 169 if (A.load.Bool(ptr + 16)) { 170 x["tabId"] = A.load.Int64(ptr + 8); 171 } else { 172 delete x["tabId"]; 173 } 174 return create === A.H.TRUE ? A.H.push(x) : ref; 175 }, 176 177 "store_SetTitleArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 178 const x = A.H.get<any>(ref); 179 180 if (typeof x === "undefined") { 181 A.store.Bool(ptr + 13, false); 182 A.store.Bool(ptr + 12, false); 183 A.store.Int64(ptr + 0, 0); 184 A.store.Ref(ptr + 8, undefined); 185 } else { 186 A.store.Bool(ptr + 13, true); 187 A.store.Bool(ptr + 12, "tabId" in x ? true : false); 188 A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 189 A.store.Ref(ptr + 8, x["title"]); 190 } 191 }, 192 "load_SetTitleArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 193 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 194 195 if (A.load.Bool(ptr + 12)) { 196 x["tabId"] = A.load.Int64(ptr + 0); 197 } else { 198 delete x["tabId"]; 199 } 200 x["title"] = A.load.Ref(ptr + 8, undefined); 201 return create === A.H.TRUE ? A.H.push(x) : ref; 202 }, 203 204 "store_TabDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 205 const x = A.H.get<any>(ref); 206 207 if (typeof x === "undefined") { 208 A.store.Bool(ptr + 9, false); 209 A.store.Bool(ptr + 8, false); 210 A.store.Int64(ptr + 0, 0); 211 } else { 212 A.store.Bool(ptr + 9, true); 213 A.store.Bool(ptr + 8, "tabId" in x ? true : false); 214 A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number)); 215 } 216 }, 217 "load_TabDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 218 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 219 220 if (A.load.Bool(ptr + 8)) { 221 x["tabId"] = A.load.Int64(ptr + 0); 222 } else { 223 delete x["tabId"]; 224 } 225 return create === A.H.TRUE ? A.H.push(x) : ref; 226 }, 227 228 "store_UserSettings": (ptr: Pointer, ref: heap.Ref<any>) => { 229 const x = A.H.get<any>(ref); 230 231 if (typeof x === "undefined") { 232 A.store.Bool(ptr + 1, false); 233 A.store.Bool(ptr + 0, false); 234 } else { 235 A.store.Bool(ptr + 1, true); 236 A.store.Bool(ptr + 0, x["isOnToolbar"] ? true : false); 237 } 238 }, 239 "load_UserSettings": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 240 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 241 242 x["isOnToolbar"] = A.load.Bool(ptr + 0); 243 return create === A.H.TRUE ? A.H.push(x) : ref; 244 }, 245 "has_Disable": (): heap.Ref<boolean> => { 246 if (WEBEXT?.action && "disable" in WEBEXT?.action) { 247 return A.H.TRUE; 248 } 249 return A.H.FALSE; 250 }, 251 "func_Disable": (fn: Pointer): void => { 252 A.store.Ref(fn, WEBEXT.action.disable); 253 }, 254 "call_Disable": (retPtr: Pointer, tabId: number): void => { 255 const _ret = WEBEXT.action.disable(tabId); 256 A.store.Ref(retPtr, _ret); 257 }, 258 "try_Disable": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 259 try { 260 const _ret = WEBEXT.action.disable(tabId); 261 A.store.Ref(retPtr, _ret); 262 return A.H.TRUE; 263 } catch (err: any) { 264 A.store.Ref(errPtr, err); 265 return A.H.FALSE; 266 } 267 }, 268 "has_Enable": (): heap.Ref<boolean> => { 269 if (WEBEXT?.action && "enable" in WEBEXT?.action) { 270 return A.H.TRUE; 271 } 272 return A.H.FALSE; 273 }, 274 "func_Enable": (fn: Pointer): void => { 275 A.store.Ref(fn, WEBEXT.action.enable); 276 }, 277 "call_Enable": (retPtr: Pointer, tabId: number): void => { 278 const _ret = WEBEXT.action.enable(tabId); 279 A.store.Ref(retPtr, _ret); 280 }, 281 "try_Enable": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 282 try { 283 const _ret = WEBEXT.action.enable(tabId); 284 A.store.Ref(retPtr, _ret); 285 return A.H.TRUE; 286 } catch (err: any) { 287 A.store.Ref(errPtr, err); 288 return A.H.FALSE; 289 } 290 }, 291 "has_GetBadgeBackgroundColor": (): heap.Ref<boolean> => { 292 if (WEBEXT?.action && "getBadgeBackgroundColor" in WEBEXT?.action) { 293 return A.H.TRUE; 294 } 295 return A.H.FALSE; 296 }, 297 "func_GetBadgeBackgroundColor": (fn: Pointer): void => { 298 A.store.Ref(fn, WEBEXT.action.getBadgeBackgroundColor); 299 }, 300 "call_GetBadgeBackgroundColor": (retPtr: Pointer, details: Pointer): void => { 301 const details_ffi = {}; 302 303 if (A.load.Bool(details + 8)) { 304 details_ffi["tabId"] = A.load.Int64(details + 0); 305 } 306 307 const _ret = WEBEXT.action.getBadgeBackgroundColor(details_ffi); 308 A.store.Ref(retPtr, _ret); 309 }, 310 "try_GetBadgeBackgroundColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 311 try { 312 const details_ffi = {}; 313 314 if (A.load.Bool(details + 8)) { 315 details_ffi["tabId"] = A.load.Int64(details + 0); 316 } 317 318 const _ret = WEBEXT.action.getBadgeBackgroundColor(details_ffi); 319 A.store.Ref(retPtr, _ret); 320 return A.H.TRUE; 321 } catch (err: any) { 322 A.store.Ref(errPtr, err); 323 return A.H.FALSE; 324 } 325 }, 326 "has_GetBadgeText": (): heap.Ref<boolean> => { 327 if (WEBEXT?.action && "getBadgeText" in WEBEXT?.action) { 328 return A.H.TRUE; 329 } 330 return A.H.FALSE; 331 }, 332 "func_GetBadgeText": (fn: Pointer): void => { 333 A.store.Ref(fn, WEBEXT.action.getBadgeText); 334 }, 335 "call_GetBadgeText": (retPtr: Pointer, details: Pointer): void => { 336 const details_ffi = {}; 337 338 if (A.load.Bool(details + 8)) { 339 details_ffi["tabId"] = A.load.Int64(details + 0); 340 } 341 342 const _ret = WEBEXT.action.getBadgeText(details_ffi); 343 A.store.Ref(retPtr, _ret); 344 }, 345 "try_GetBadgeText": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 346 try { 347 const details_ffi = {}; 348 349 if (A.load.Bool(details + 8)) { 350 details_ffi["tabId"] = A.load.Int64(details + 0); 351 } 352 353 const _ret = WEBEXT.action.getBadgeText(details_ffi); 354 A.store.Ref(retPtr, _ret); 355 return A.H.TRUE; 356 } catch (err: any) { 357 A.store.Ref(errPtr, err); 358 return A.H.FALSE; 359 } 360 }, 361 "has_GetBadgeTextColor": (): heap.Ref<boolean> => { 362 if (WEBEXT?.action && "getBadgeTextColor" in WEBEXT?.action) { 363 return A.H.TRUE; 364 } 365 return A.H.FALSE; 366 }, 367 "func_GetBadgeTextColor": (fn: Pointer): void => { 368 A.store.Ref(fn, WEBEXT.action.getBadgeTextColor); 369 }, 370 "call_GetBadgeTextColor": (retPtr: Pointer, details: Pointer): void => { 371 const details_ffi = {}; 372 373 if (A.load.Bool(details + 8)) { 374 details_ffi["tabId"] = A.load.Int64(details + 0); 375 } 376 377 const _ret = WEBEXT.action.getBadgeTextColor(details_ffi); 378 A.store.Ref(retPtr, _ret); 379 }, 380 "try_GetBadgeTextColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 381 try { 382 const details_ffi = {}; 383 384 if (A.load.Bool(details + 8)) { 385 details_ffi["tabId"] = A.load.Int64(details + 0); 386 } 387 388 const _ret = WEBEXT.action.getBadgeTextColor(details_ffi); 389 A.store.Ref(retPtr, _ret); 390 return A.H.TRUE; 391 } catch (err: any) { 392 A.store.Ref(errPtr, err); 393 return A.H.FALSE; 394 } 395 }, 396 "has_GetPopup": (): heap.Ref<boolean> => { 397 if (WEBEXT?.action && "getPopup" in WEBEXT?.action) { 398 return A.H.TRUE; 399 } 400 return A.H.FALSE; 401 }, 402 "func_GetPopup": (fn: Pointer): void => { 403 A.store.Ref(fn, WEBEXT.action.getPopup); 404 }, 405 "call_GetPopup": (retPtr: Pointer, details: Pointer): void => { 406 const details_ffi = {}; 407 408 if (A.load.Bool(details + 8)) { 409 details_ffi["tabId"] = A.load.Int64(details + 0); 410 } 411 412 const _ret = WEBEXT.action.getPopup(details_ffi); 413 A.store.Ref(retPtr, _ret); 414 }, 415 "try_GetPopup": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 416 try { 417 const details_ffi = {}; 418 419 if (A.load.Bool(details + 8)) { 420 details_ffi["tabId"] = A.load.Int64(details + 0); 421 } 422 423 const _ret = WEBEXT.action.getPopup(details_ffi); 424 A.store.Ref(retPtr, _ret); 425 return A.H.TRUE; 426 } catch (err: any) { 427 A.store.Ref(errPtr, err); 428 return A.H.FALSE; 429 } 430 }, 431 "has_GetTitle": (): heap.Ref<boolean> => { 432 if (WEBEXT?.action && "getTitle" in WEBEXT?.action) { 433 return A.H.TRUE; 434 } 435 return A.H.FALSE; 436 }, 437 "func_GetTitle": (fn: Pointer): void => { 438 A.store.Ref(fn, WEBEXT.action.getTitle); 439 }, 440 "call_GetTitle": (retPtr: Pointer, details: Pointer): void => { 441 const details_ffi = {}; 442 443 if (A.load.Bool(details + 8)) { 444 details_ffi["tabId"] = A.load.Int64(details + 0); 445 } 446 447 const _ret = WEBEXT.action.getTitle(details_ffi); 448 A.store.Ref(retPtr, _ret); 449 }, 450 "try_GetTitle": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 451 try { 452 const details_ffi = {}; 453 454 if (A.load.Bool(details + 8)) { 455 details_ffi["tabId"] = A.load.Int64(details + 0); 456 } 457 458 const _ret = WEBEXT.action.getTitle(details_ffi); 459 A.store.Ref(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_GetUserSettings": (): heap.Ref<boolean> => { 467 if (WEBEXT?.action && "getUserSettings" in WEBEXT?.action) { 468 return A.H.TRUE; 469 } 470 return A.H.FALSE; 471 }, 472 "func_GetUserSettings": (fn: Pointer): void => { 473 A.store.Ref(fn, WEBEXT.action.getUserSettings); 474 }, 475 "call_GetUserSettings": (retPtr: Pointer): void => { 476 const _ret = WEBEXT.action.getUserSettings(); 477 A.store.Ref(retPtr, _ret); 478 }, 479 "try_GetUserSettings": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 480 try { 481 const _ret = WEBEXT.action.getUserSettings(); 482 A.store.Ref(retPtr, _ret); 483 return A.H.TRUE; 484 } catch (err: any) { 485 A.store.Ref(errPtr, err); 486 return A.H.FALSE; 487 } 488 }, 489 "has_IsEnabled": (): heap.Ref<boolean> => { 490 if (WEBEXT?.action && "isEnabled" in WEBEXT?.action) { 491 return A.H.TRUE; 492 } 493 return A.H.FALSE; 494 }, 495 "func_IsEnabled": (fn: Pointer): void => { 496 A.store.Ref(fn, WEBEXT.action.isEnabled); 497 }, 498 "call_IsEnabled": (retPtr: Pointer, tabId: number): void => { 499 const _ret = WEBEXT.action.isEnabled(tabId); 500 A.store.Ref(retPtr, _ret); 501 }, 502 "try_IsEnabled": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => { 503 try { 504 const _ret = WEBEXT.action.isEnabled(tabId); 505 A.store.Ref(retPtr, _ret); 506 return A.H.TRUE; 507 } catch (err: any) { 508 A.store.Ref(errPtr, err); 509 return A.H.FALSE; 510 } 511 }, 512 "has_OnClicked": (): heap.Ref<boolean> => { 513 if (WEBEXT?.action?.onClicked && "addListener" in WEBEXT?.action?.onClicked) { 514 return A.H.TRUE; 515 } 516 return A.H.FALSE; 517 }, 518 "func_OnClicked": (fn: Pointer): void => { 519 A.store.Ref(fn, WEBEXT.action.onClicked.addListener); 520 }, 521 "call_OnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 522 const _ret = WEBEXT.action.onClicked.addListener(A.H.get<object>(callback)); 523 }, 524 "try_OnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 525 try { 526 const _ret = WEBEXT.action.onClicked.addListener(A.H.get<object>(callback)); 527 return A.H.TRUE; 528 } catch (err: any) { 529 A.store.Ref(errPtr, err); 530 return A.H.FALSE; 531 } 532 }, 533 "has_OffClicked": (): heap.Ref<boolean> => { 534 if (WEBEXT?.action?.onClicked && "removeListener" in WEBEXT?.action?.onClicked) { 535 return A.H.TRUE; 536 } 537 return A.H.FALSE; 538 }, 539 "func_OffClicked": (fn: Pointer): void => { 540 A.store.Ref(fn, WEBEXT.action.onClicked.removeListener); 541 }, 542 "call_OffClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 543 const _ret = WEBEXT.action.onClicked.removeListener(A.H.get<object>(callback)); 544 }, 545 "try_OffClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 546 try { 547 const _ret = WEBEXT.action.onClicked.removeListener(A.H.get<object>(callback)); 548 return A.H.TRUE; 549 } catch (err: any) { 550 A.store.Ref(errPtr, err); 551 return A.H.FALSE; 552 } 553 }, 554 "has_HasOnClicked": (): heap.Ref<boolean> => { 555 if (WEBEXT?.action?.onClicked && "hasListener" in WEBEXT?.action?.onClicked) { 556 return A.H.TRUE; 557 } 558 return A.H.FALSE; 559 }, 560 "func_HasOnClicked": (fn: Pointer): void => { 561 A.store.Ref(fn, WEBEXT.action.onClicked.hasListener); 562 }, 563 "call_HasOnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 564 const _ret = WEBEXT.action.onClicked.hasListener(A.H.get<object>(callback)); 565 A.store.Bool(retPtr, _ret); 566 }, 567 "try_HasOnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 568 try { 569 const _ret = WEBEXT.action.onClicked.hasListener(A.H.get<object>(callback)); 570 A.store.Bool(retPtr, _ret); 571 return A.H.TRUE; 572 } catch (err: any) { 573 A.store.Ref(errPtr, err); 574 return A.H.FALSE; 575 } 576 }, 577 "has_OpenPopup": (): heap.Ref<boolean> => { 578 if (WEBEXT?.action && "openPopup" in WEBEXT?.action) { 579 return A.H.TRUE; 580 } 581 return A.H.FALSE; 582 }, 583 "func_OpenPopup": (fn: Pointer): void => { 584 A.store.Ref(fn, WEBEXT.action.openPopup); 585 }, 586 "call_OpenPopup": (retPtr: Pointer, options: Pointer): void => { 587 const options_ffi = {}; 588 589 if (A.load.Bool(options + 8)) { 590 options_ffi["windowId"] = A.load.Int64(options + 0); 591 } 592 593 const _ret = WEBEXT.action.openPopup(options_ffi); 594 A.store.Ref(retPtr, _ret); 595 }, 596 "try_OpenPopup": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 597 try { 598 const options_ffi = {}; 599 600 if (A.load.Bool(options + 8)) { 601 options_ffi["windowId"] = A.load.Int64(options + 0); 602 } 603 604 const _ret = WEBEXT.action.openPopup(options_ffi); 605 A.store.Ref(retPtr, _ret); 606 return A.H.TRUE; 607 } catch (err: any) { 608 A.store.Ref(errPtr, err); 609 return A.H.FALSE; 610 } 611 }, 612 "has_SetBadgeBackgroundColor": (): heap.Ref<boolean> => { 613 if (WEBEXT?.action && "setBadgeBackgroundColor" in WEBEXT?.action) { 614 return A.H.TRUE; 615 } 616 return A.H.FALSE; 617 }, 618 "func_SetBadgeBackgroundColor": (fn: Pointer): void => { 619 A.store.Ref(fn, WEBEXT.action.setBadgeBackgroundColor); 620 }, 621 "call_SetBadgeBackgroundColor": (retPtr: Pointer, details: Pointer): void => { 622 const details_ffi = {}; 623 624 details_ffi["color"] = A.load.Ref(details + 0, undefined); 625 if (A.load.Bool(details + 16)) { 626 details_ffi["tabId"] = A.load.Int64(details + 8); 627 } 628 629 const _ret = WEBEXT.action.setBadgeBackgroundColor(details_ffi); 630 A.store.Ref(retPtr, _ret); 631 }, 632 "try_SetBadgeBackgroundColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 633 try { 634 const details_ffi = {}; 635 636 details_ffi["color"] = A.load.Ref(details + 0, undefined); 637 if (A.load.Bool(details + 16)) { 638 details_ffi["tabId"] = A.load.Int64(details + 8); 639 } 640 641 const _ret = WEBEXT.action.setBadgeBackgroundColor(details_ffi); 642 A.store.Ref(retPtr, _ret); 643 return A.H.TRUE; 644 } catch (err: any) { 645 A.store.Ref(errPtr, err); 646 return A.H.FALSE; 647 } 648 }, 649 "has_SetBadgeText": (): heap.Ref<boolean> => { 650 if (WEBEXT?.action && "setBadgeText" in WEBEXT?.action) { 651 return A.H.TRUE; 652 } 653 return A.H.FALSE; 654 }, 655 "func_SetBadgeText": (fn: Pointer): void => { 656 A.store.Ref(fn, WEBEXT.action.setBadgeText); 657 }, 658 "call_SetBadgeText": (retPtr: Pointer, details: Pointer): void => { 659 const details_ffi = {}; 660 661 if (A.load.Bool(details + 12)) { 662 details_ffi["tabId"] = A.load.Int64(details + 0); 663 } 664 details_ffi["text"] = A.load.Ref(details + 8, undefined); 665 666 const _ret = WEBEXT.action.setBadgeText(details_ffi); 667 A.store.Ref(retPtr, _ret); 668 }, 669 "try_SetBadgeText": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 670 try { 671 const details_ffi = {}; 672 673 if (A.load.Bool(details + 12)) { 674 details_ffi["tabId"] = A.load.Int64(details + 0); 675 } 676 details_ffi["text"] = A.load.Ref(details + 8, undefined); 677 678 const _ret = WEBEXT.action.setBadgeText(details_ffi); 679 A.store.Ref(retPtr, _ret); 680 return A.H.TRUE; 681 } catch (err: any) { 682 A.store.Ref(errPtr, err); 683 return A.H.FALSE; 684 } 685 }, 686 "has_SetBadgeTextColor": (): heap.Ref<boolean> => { 687 if (WEBEXT?.action && "setBadgeTextColor" in WEBEXT?.action) { 688 return A.H.TRUE; 689 } 690 return A.H.FALSE; 691 }, 692 "func_SetBadgeTextColor": (fn: Pointer): void => { 693 A.store.Ref(fn, WEBEXT.action.setBadgeTextColor); 694 }, 695 "call_SetBadgeTextColor": (retPtr: Pointer, details: Pointer): void => { 696 const details_ffi = {}; 697 698 details_ffi["color"] = A.load.Ref(details + 0, undefined); 699 if (A.load.Bool(details + 16)) { 700 details_ffi["tabId"] = A.load.Int64(details + 8); 701 } 702 703 const _ret = WEBEXT.action.setBadgeTextColor(details_ffi); 704 A.store.Ref(retPtr, _ret); 705 }, 706 "try_SetBadgeTextColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 707 try { 708 const details_ffi = {}; 709 710 details_ffi["color"] = A.load.Ref(details + 0, undefined); 711 if (A.load.Bool(details + 16)) { 712 details_ffi["tabId"] = A.load.Int64(details + 8); 713 } 714 715 const _ret = WEBEXT.action.setBadgeTextColor(details_ffi); 716 A.store.Ref(retPtr, _ret); 717 return A.H.TRUE; 718 } catch (err: any) { 719 A.store.Ref(errPtr, err); 720 return A.H.FALSE; 721 } 722 }, 723 "has_SetIcon": (): heap.Ref<boolean> => { 724 if (WEBEXT?.action && "setIcon" in WEBEXT?.action) { 725 return A.H.TRUE; 726 } 727 return A.H.FALSE; 728 }, 729 "func_SetIcon": (fn: Pointer): void => { 730 A.store.Ref(fn, WEBEXT.action.setIcon); 731 }, 732 "call_SetIcon": (retPtr: Pointer, details: Pointer): void => { 733 const details_ffi = {}; 734 735 details_ffi["imageData"] = A.load.Ref(details + 0, undefined); 736 details_ffi["path"] = A.load.Ref(details + 4, undefined); 737 if (A.load.Bool(details + 16)) { 738 details_ffi["tabId"] = A.load.Int64(details + 8); 739 } 740 741 const _ret = WEBEXT.action.setIcon(details_ffi); 742 A.store.Ref(retPtr, _ret); 743 }, 744 "try_SetIcon": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 745 try { 746 const details_ffi = {}; 747 748 details_ffi["imageData"] = A.load.Ref(details + 0, undefined); 749 details_ffi["path"] = A.load.Ref(details + 4, undefined); 750 if (A.load.Bool(details + 16)) { 751 details_ffi["tabId"] = A.load.Int64(details + 8); 752 } 753 754 const _ret = WEBEXT.action.setIcon(details_ffi); 755 A.store.Ref(retPtr, _ret); 756 return A.H.TRUE; 757 } catch (err: any) { 758 A.store.Ref(errPtr, err); 759 return A.H.FALSE; 760 } 761 }, 762 "has_SetPopup": (): heap.Ref<boolean> => { 763 if (WEBEXT?.action && "setPopup" in WEBEXT?.action) { 764 return A.H.TRUE; 765 } 766 return A.H.FALSE; 767 }, 768 "func_SetPopup": (fn: Pointer): void => { 769 A.store.Ref(fn, WEBEXT.action.setPopup); 770 }, 771 "call_SetPopup": (retPtr: Pointer, details: Pointer): void => { 772 const details_ffi = {}; 773 774 details_ffi["popup"] = A.load.Ref(details + 0, undefined); 775 if (A.load.Bool(details + 16)) { 776 details_ffi["tabId"] = A.load.Int64(details + 8); 777 } 778 779 const _ret = WEBEXT.action.setPopup(details_ffi); 780 A.store.Ref(retPtr, _ret); 781 }, 782 "try_SetPopup": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 783 try { 784 const details_ffi = {}; 785 786 details_ffi["popup"] = A.load.Ref(details + 0, undefined); 787 if (A.load.Bool(details + 16)) { 788 details_ffi["tabId"] = A.load.Int64(details + 8); 789 } 790 791 const _ret = WEBEXT.action.setPopup(details_ffi); 792 A.store.Ref(retPtr, _ret); 793 return A.H.TRUE; 794 } catch (err: any) { 795 A.store.Ref(errPtr, err); 796 return A.H.FALSE; 797 } 798 }, 799 "has_SetTitle": (): heap.Ref<boolean> => { 800 if (WEBEXT?.action && "setTitle" in WEBEXT?.action) { 801 return A.H.TRUE; 802 } 803 return A.H.FALSE; 804 }, 805 "func_SetTitle": (fn: Pointer): void => { 806 A.store.Ref(fn, WEBEXT.action.setTitle); 807 }, 808 "call_SetTitle": (retPtr: Pointer, details: Pointer): void => { 809 const details_ffi = {}; 810 811 if (A.load.Bool(details + 12)) { 812 details_ffi["tabId"] = A.load.Int64(details + 0); 813 } 814 details_ffi["title"] = A.load.Ref(details + 8, undefined); 815 816 const _ret = WEBEXT.action.setTitle(details_ffi); 817 A.store.Ref(retPtr, _ret); 818 }, 819 "try_SetTitle": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => { 820 try { 821 const details_ffi = {}; 822 823 if (A.load.Bool(details + 12)) { 824 details_ffi["tabId"] = A.load.Int64(details + 0); 825 } 826 details_ffi["title"] = A.load.Ref(details + 8, undefined); 827 828 const _ret = WEBEXT.action.setTitle(details_ffi); 829 A.store.Ref(retPtr, _ret); 830 return A.H.TRUE; 831 } catch (err: any) { 832 A.store.Ref(errPtr, err); 833 return A.H.FALSE; 834 } 835 }, 836 }; 837 });