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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/sidepanel", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_GetPanelOptions": (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 + 5, false);
    12          A.store.Bool(ptr + 4, false);
    13          A.store.Int32(ptr + 0, 0);
    14        } else {
    15          A.store.Bool(ptr + 5, true);
    16          A.store.Bool(ptr + 4, "tabId" in x ? true : false);
    17          A.store.Int32(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    18        }
    19      },
    20      "load_GetPanelOptions": (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 + 4)) {
    24          x["tabId"] = A.load.Int32(ptr + 0);
    25        } else {
    26          delete x["tabId"];
    27        }
    28        return create === A.H.TRUE ? A.H.push(x) : ref;
    29      },
    30  
    31      "store_SidePanel": (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 + 4, false);
    36          A.store.Ref(ptr + 0, undefined);
    37        } else {
    38          A.store.Bool(ptr + 4, true);
    39          A.store.Ref(ptr + 0, x["default_path"]);
    40        }
    41      },
    42      "load_SidePanel": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    43        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    44  
    45        x["default_path"] = A.load.Ref(ptr + 0, undefined);
    46        return create === A.H.TRUE ? A.H.push(x) : ref;
    47      },
    48  
    49      "store_ManifestKeys": (ptr: Pointer, ref: heap.Ref<any>) => {
    50        const x = A.H.get<any>(ref);
    51  
    52        if (typeof x === "undefined") {
    53          A.store.Bool(ptr + 5, false);
    54  
    55          A.store.Bool(ptr + 0 + 4, false);
    56          A.store.Ref(ptr + 0 + 0, undefined);
    57        } else {
    58          A.store.Bool(ptr + 5, true);
    59  
    60          if (typeof x["side_panel"] === "undefined") {
    61            A.store.Bool(ptr + 0 + 4, false);
    62            A.store.Ref(ptr + 0 + 0, undefined);
    63          } else {
    64            A.store.Bool(ptr + 0 + 4, true);
    65            A.store.Ref(ptr + 0 + 0, x["side_panel"]["default_path"]);
    66          }
    67        }
    68      },
    69      "load_ManifestKeys": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    70        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    71  
    72        if (A.load.Bool(ptr + 0 + 4)) {
    73          x["side_panel"] = {};
    74          x["side_panel"]["default_path"] = A.load.Ref(ptr + 0 + 0, undefined);
    75        } else {
    76          delete x["side_panel"];
    77        }
    78        return create === A.H.TRUE ? A.H.push(x) : ref;
    79      },
    80  
    81      "store_OpenOptions": (ptr: Pointer, ref: heap.Ref<any>) => {
    82        const x = A.H.get<any>(ref);
    83  
    84        if (typeof x === "undefined") {
    85          A.store.Bool(ptr + 10, false);
    86          A.store.Bool(ptr + 8, false);
    87          A.store.Int32(ptr + 0, 0);
    88          A.store.Bool(ptr + 9, false);
    89          A.store.Int32(ptr + 4, 0);
    90        } else {
    91          A.store.Bool(ptr + 10, true);
    92          A.store.Bool(ptr + 8, "windowId" in x ? true : false);
    93          A.store.Int32(ptr + 0, x["windowId"] === undefined ? 0 : (x["windowId"] as number));
    94          A.store.Bool(ptr + 9, "tabId" in x ? true : false);
    95          A.store.Int32(ptr + 4, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    96        }
    97      },
    98      "load_OpenOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    99        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   100  
   101        if (A.load.Bool(ptr + 8)) {
   102          x["windowId"] = A.load.Int32(ptr + 0);
   103        } else {
   104          delete x["windowId"];
   105        }
   106        if (A.load.Bool(ptr + 9)) {
   107          x["tabId"] = A.load.Int32(ptr + 4);
   108        } else {
   109          delete x["tabId"];
   110        }
   111        return create === A.H.TRUE ? A.H.push(x) : ref;
   112      },
   113  
   114      "store_PanelBehavior": (ptr: Pointer, ref: heap.Ref<any>) => {
   115        const x = A.H.get<any>(ref);
   116  
   117        if (typeof x === "undefined") {
   118          A.store.Bool(ptr + 2, false);
   119          A.store.Bool(ptr + 1, false);
   120          A.store.Bool(ptr + 0, false);
   121        } else {
   122          A.store.Bool(ptr + 2, true);
   123          A.store.Bool(ptr + 1, "openPanelOnActionClick" in x ? true : false);
   124          A.store.Bool(ptr + 0, x["openPanelOnActionClick"] ? true : false);
   125        }
   126      },
   127      "load_PanelBehavior": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   128        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   129  
   130        if (A.load.Bool(ptr + 1)) {
   131          x["openPanelOnActionClick"] = A.load.Bool(ptr + 0);
   132        } else {
   133          delete x["openPanelOnActionClick"];
   134        }
   135        return create === A.H.TRUE ? A.H.push(x) : ref;
   136      },
   137  
   138      "store_PanelOptions": (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 + 11, false);
   143          A.store.Bool(ptr + 9, false);
   144          A.store.Int32(ptr + 0, 0);
   145          A.store.Ref(ptr + 4, undefined);
   146          A.store.Bool(ptr + 10, false);
   147          A.store.Bool(ptr + 8, false);
   148        } else {
   149          A.store.Bool(ptr + 11, true);
   150          A.store.Bool(ptr + 9, "tabId" in x ? true : false);
   151          A.store.Int32(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   152          A.store.Ref(ptr + 4, x["path"]);
   153          A.store.Bool(ptr + 10, "enabled" in x ? true : false);
   154          A.store.Bool(ptr + 8, x["enabled"] ? true : false);
   155        }
   156      },
   157      "load_PanelOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   158        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   159  
   160        if (A.load.Bool(ptr + 9)) {
   161          x["tabId"] = A.load.Int32(ptr + 0);
   162        } else {
   163          delete x["tabId"];
   164        }
   165        x["path"] = A.load.Ref(ptr + 4, undefined);
   166        if (A.load.Bool(ptr + 10)) {
   167          x["enabled"] = A.load.Bool(ptr + 8);
   168        } else {
   169          delete x["enabled"];
   170        }
   171        return create === A.H.TRUE ? A.H.push(x) : ref;
   172      },
   173      "has_GetOptions": (): heap.Ref<boolean> => {
   174        if (WEBEXT?.sidePanel && "getOptions" in WEBEXT?.sidePanel) {
   175          return A.H.TRUE;
   176        }
   177        return A.H.FALSE;
   178      },
   179      "func_GetOptions": (fn: Pointer): void => {
   180        A.store.Ref(fn, WEBEXT.sidePanel.getOptions);
   181      },
   182      "call_GetOptions": (retPtr: Pointer, options: Pointer): void => {
   183        const options_ffi = {};
   184  
   185        if (A.load.Bool(options + 4)) {
   186          options_ffi["tabId"] = A.load.Int32(options + 0);
   187        }
   188  
   189        const _ret = WEBEXT.sidePanel.getOptions(options_ffi);
   190        A.store.Ref(retPtr, _ret);
   191      },
   192      "try_GetOptions": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => {
   193        try {
   194          const options_ffi = {};
   195  
   196          if (A.load.Bool(options + 4)) {
   197            options_ffi["tabId"] = A.load.Int32(options + 0);
   198          }
   199  
   200          const _ret = WEBEXT.sidePanel.getOptions(options_ffi);
   201          A.store.Ref(retPtr, _ret);
   202          return A.H.TRUE;
   203        } catch (err: any) {
   204          A.store.Ref(errPtr, err);
   205          return A.H.FALSE;
   206        }
   207      },
   208      "has_GetPanelBehavior": (): heap.Ref<boolean> => {
   209        if (WEBEXT?.sidePanel && "getPanelBehavior" in WEBEXT?.sidePanel) {
   210          return A.H.TRUE;
   211        }
   212        return A.H.FALSE;
   213      },
   214      "func_GetPanelBehavior": (fn: Pointer): void => {
   215        A.store.Ref(fn, WEBEXT.sidePanel.getPanelBehavior);
   216      },
   217      "call_GetPanelBehavior": (retPtr: Pointer): void => {
   218        const _ret = WEBEXT.sidePanel.getPanelBehavior();
   219        A.store.Ref(retPtr, _ret);
   220      },
   221      "try_GetPanelBehavior": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   222        try {
   223          const _ret = WEBEXT.sidePanel.getPanelBehavior();
   224          A.store.Ref(retPtr, _ret);
   225          return A.H.TRUE;
   226        } catch (err: any) {
   227          A.store.Ref(errPtr, err);
   228          return A.H.FALSE;
   229        }
   230      },
   231      "has_Open": (): heap.Ref<boolean> => {
   232        if (WEBEXT?.sidePanel && "open" in WEBEXT?.sidePanel) {
   233          return A.H.TRUE;
   234        }
   235        return A.H.FALSE;
   236      },
   237      "func_Open": (fn: Pointer): void => {
   238        A.store.Ref(fn, WEBEXT.sidePanel.open);
   239      },
   240      "call_Open": (retPtr: Pointer, options: Pointer): void => {
   241        const options_ffi = {};
   242  
   243        if (A.load.Bool(options + 8)) {
   244          options_ffi["windowId"] = A.load.Int32(options + 0);
   245        }
   246        if (A.load.Bool(options + 9)) {
   247          options_ffi["tabId"] = A.load.Int32(options + 4);
   248        }
   249  
   250        const _ret = WEBEXT.sidePanel.open(options_ffi);
   251        A.store.Ref(retPtr, _ret);
   252      },
   253      "try_Open": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => {
   254        try {
   255          const options_ffi = {};
   256  
   257          if (A.load.Bool(options + 8)) {
   258            options_ffi["windowId"] = A.load.Int32(options + 0);
   259          }
   260          if (A.load.Bool(options + 9)) {
   261            options_ffi["tabId"] = A.load.Int32(options + 4);
   262          }
   263  
   264          const _ret = WEBEXT.sidePanel.open(options_ffi);
   265          A.store.Ref(retPtr, _ret);
   266          return A.H.TRUE;
   267        } catch (err: any) {
   268          A.store.Ref(errPtr, err);
   269          return A.H.FALSE;
   270        }
   271      },
   272      "has_SetOptions": (): heap.Ref<boolean> => {
   273        if (WEBEXT?.sidePanel && "setOptions" in WEBEXT?.sidePanel) {
   274          return A.H.TRUE;
   275        }
   276        return A.H.FALSE;
   277      },
   278      "func_SetOptions": (fn: Pointer): void => {
   279        A.store.Ref(fn, WEBEXT.sidePanel.setOptions);
   280      },
   281      "call_SetOptions": (retPtr: Pointer, options: Pointer): void => {
   282        const options_ffi = {};
   283  
   284        if (A.load.Bool(options + 9)) {
   285          options_ffi["tabId"] = A.load.Int32(options + 0);
   286        }
   287        options_ffi["path"] = A.load.Ref(options + 4, undefined);
   288        if (A.load.Bool(options + 10)) {
   289          options_ffi["enabled"] = A.load.Bool(options + 8);
   290        }
   291  
   292        const _ret = WEBEXT.sidePanel.setOptions(options_ffi);
   293        A.store.Ref(retPtr, _ret);
   294      },
   295      "try_SetOptions": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => {
   296        try {
   297          const options_ffi = {};
   298  
   299          if (A.load.Bool(options + 9)) {
   300            options_ffi["tabId"] = A.load.Int32(options + 0);
   301          }
   302          options_ffi["path"] = A.load.Ref(options + 4, undefined);
   303          if (A.load.Bool(options + 10)) {
   304            options_ffi["enabled"] = A.load.Bool(options + 8);
   305          }
   306  
   307          const _ret = WEBEXT.sidePanel.setOptions(options_ffi);
   308          A.store.Ref(retPtr, _ret);
   309          return A.H.TRUE;
   310        } catch (err: any) {
   311          A.store.Ref(errPtr, err);
   312          return A.H.FALSE;
   313        }
   314      },
   315      "has_SetPanelBehavior": (): heap.Ref<boolean> => {
   316        if (WEBEXT?.sidePanel && "setPanelBehavior" in WEBEXT?.sidePanel) {
   317          return A.H.TRUE;
   318        }
   319        return A.H.FALSE;
   320      },
   321      "func_SetPanelBehavior": (fn: Pointer): void => {
   322        A.store.Ref(fn, WEBEXT.sidePanel.setPanelBehavior);
   323      },
   324      "call_SetPanelBehavior": (retPtr: Pointer, behavior: Pointer): void => {
   325        const behavior_ffi = {};
   326  
   327        if (A.load.Bool(behavior + 1)) {
   328          behavior_ffi["openPanelOnActionClick"] = A.load.Bool(behavior + 0);
   329        }
   330  
   331        const _ret = WEBEXT.sidePanel.setPanelBehavior(behavior_ffi);
   332        A.store.Ref(retPtr, _ret);
   333      },
   334      "try_SetPanelBehavior": (retPtr: Pointer, errPtr: Pointer, behavior: Pointer): heap.Ref<boolean> => {
   335        try {
   336          const behavior_ffi = {};
   337  
   338          if (A.load.Bool(behavior + 1)) {
   339            behavior_ffi["openPanelOnActionClick"] = A.load.Bool(behavior + 0);
   340          }
   341  
   342          const _ret = WEBEXT.sidePanel.setPanelBehavior(behavior_ffi);
   343          A.store.Ref(retPtr, _ret);
   344          return A.H.TRUE;
   345        } catch (err: any) {
   346          A.store.Ref(errPtr, err);
   347          return A.H.FALSE;
   348        }
   349      },
   350    };
   351  });