github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/commands/bindings/ffi_bindings.ts (about)

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/commands", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_Command": (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 + 12, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14          A.store.Ref(ptr + 8, undefined);
    15        } else {
    16          A.store.Bool(ptr + 12, true);
    17          A.store.Ref(ptr + 0, x["description"]);
    18          A.store.Ref(ptr + 4, x["name"]);
    19          A.store.Ref(ptr + 8, x["shortcut"]);
    20        }
    21      },
    22      "load_Command": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    23        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    24  
    25        x["description"] = A.load.Ref(ptr + 0, undefined);
    26        x["name"] = A.load.Ref(ptr + 4, undefined);
    27        x["shortcut"] = A.load.Ref(ptr + 8, undefined);
    28        return create === A.H.TRUE ? A.H.push(x) : ref;
    29      },
    30      "has_GetAll": (): heap.Ref<boolean> => {
    31        if (WEBEXT?.commands && "getAll" in WEBEXT?.commands) {
    32          return A.H.TRUE;
    33        }
    34        return A.H.FALSE;
    35      },
    36      "func_GetAll": (fn: Pointer): void => {
    37        A.store.Ref(fn, WEBEXT.commands.getAll);
    38      },
    39      "call_GetAll": (retPtr: Pointer): void => {
    40        const _ret = WEBEXT.commands.getAll();
    41        A.store.Ref(retPtr, _ret);
    42      },
    43      "try_GetAll": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    44        try {
    45          const _ret = WEBEXT.commands.getAll();
    46          A.store.Ref(retPtr, _ret);
    47          return A.H.TRUE;
    48        } catch (err: any) {
    49          A.store.Ref(errPtr, err);
    50          return A.H.FALSE;
    51        }
    52      },
    53      "has_OnCommand": (): heap.Ref<boolean> => {
    54        if (WEBEXT?.commands?.onCommand && "addListener" in WEBEXT?.commands?.onCommand) {
    55          return A.H.TRUE;
    56        }
    57        return A.H.FALSE;
    58      },
    59      "func_OnCommand": (fn: Pointer): void => {
    60        A.store.Ref(fn, WEBEXT.commands.onCommand.addListener);
    61      },
    62      "call_OnCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => {
    63        const _ret = WEBEXT.commands.onCommand.addListener(A.H.get<object>(callback));
    64      },
    65      "try_OnCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
    66        try {
    67          const _ret = WEBEXT.commands.onCommand.addListener(A.H.get<object>(callback));
    68          return A.H.TRUE;
    69        } catch (err: any) {
    70          A.store.Ref(errPtr, err);
    71          return A.H.FALSE;
    72        }
    73      },
    74      "has_OffCommand": (): heap.Ref<boolean> => {
    75        if (WEBEXT?.commands?.onCommand && "removeListener" in WEBEXT?.commands?.onCommand) {
    76          return A.H.TRUE;
    77        }
    78        return A.H.FALSE;
    79      },
    80      "func_OffCommand": (fn: Pointer): void => {
    81        A.store.Ref(fn, WEBEXT.commands.onCommand.removeListener);
    82      },
    83      "call_OffCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => {
    84        const _ret = WEBEXT.commands.onCommand.removeListener(A.H.get<object>(callback));
    85      },
    86      "try_OffCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
    87        try {
    88          const _ret = WEBEXT.commands.onCommand.removeListener(A.H.get<object>(callback));
    89          return A.H.TRUE;
    90        } catch (err: any) {
    91          A.store.Ref(errPtr, err);
    92          return A.H.FALSE;
    93        }
    94      },
    95      "has_HasOnCommand": (): heap.Ref<boolean> => {
    96        if (WEBEXT?.commands?.onCommand && "hasListener" in WEBEXT?.commands?.onCommand) {
    97          return A.H.TRUE;
    98        }
    99        return A.H.FALSE;
   100      },
   101      "func_HasOnCommand": (fn: Pointer): void => {
   102        A.store.Ref(fn, WEBEXT.commands.onCommand.hasListener);
   103      },
   104      "call_HasOnCommand": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   105        const _ret = WEBEXT.commands.onCommand.hasListener(A.H.get<object>(callback));
   106        A.store.Bool(retPtr, _ret);
   107      },
   108      "try_HasOnCommand": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   109        try {
   110          const _ret = WEBEXT.commands.onCommand.hasListener(A.H.get<object>(callback));
   111          A.store.Bool(retPtr, _ret);
   112          return A.H.TRUE;
   113        } catch (err: any) {
   114          A.store.Ref(errPtr, err);
   115          return A.H.FALSE;
   116        }
   117      },
   118    };
   119  });