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  });