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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/extension", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "constof_ViewType": (ref: heap.Ref<string>): number => {
     8        const idx = ["tab", "popup"].indexOf(A.H.get(ref));
     9        return idx < 0 ? 0 : idx + 1;
    10      },
    11  
    12      "store_GetViewsArgFetchProperties": (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 + 26, false);
    17          A.store.Bool(ptr + 24, false);
    18          A.store.Int64(ptr + 0, 0);
    19          A.store.Enum(ptr + 8, -1);
    20          A.store.Bool(ptr + 25, false);
    21          A.store.Int64(ptr + 16, 0);
    22        } else {
    23          A.store.Bool(ptr + 26, true);
    24          A.store.Bool(ptr + 24, "tabId" in x ? true : false);
    25          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    26          A.store.Enum(ptr + 8, ["tab", "popup"].indexOf(x["type"] as string));
    27          A.store.Bool(ptr + 25, "windowId" in x ? true : false);
    28          A.store.Int64(ptr + 16, x["windowId"] === undefined ? 0 : (x["windowId"] as number));
    29        }
    30      },
    31      "load_GetViewsArgFetchProperties": (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        if (A.load.Bool(ptr + 24)) {
    35          x["tabId"] = A.load.Int64(ptr + 0);
    36        } else {
    37          delete x["tabId"];
    38        }
    39        x["type"] = A.load.Enum(ptr + 8, ["tab", "popup"]);
    40        if (A.load.Bool(ptr + 25)) {
    41          x["windowId"] = A.load.Int64(ptr + 16);
    42        } else {
    43          delete x["windowId"];
    44        }
    45        return create === A.H.TRUE ? A.H.push(x) : ref;
    46      },
    47  
    48      "store_LastErrorProperty": (ptr: Pointer, ref: heap.Ref<any>) => {
    49        const x = A.H.get<any>(ref);
    50  
    51        if (typeof x === "undefined") {
    52          A.store.Bool(ptr + 4, false);
    53          A.store.Ref(ptr + 0, undefined);
    54        } else {
    55          A.store.Bool(ptr + 4, true);
    56          A.store.Ref(ptr + 0, x["message"]);
    57        }
    58      },
    59      "load_LastErrorProperty": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    60        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    61  
    62        x["message"] = A.load.Ref(ptr + 0, undefined);
    63        return create === A.H.TRUE ? A.H.push(x) : ref;
    64      },
    65      "has_GetBackgroundPage": (): heap.Ref<boolean> => {
    66        if (WEBEXT?.extension && "getBackgroundPage" in WEBEXT?.extension) {
    67          return A.H.TRUE;
    68        }
    69        return A.H.FALSE;
    70      },
    71      "func_GetBackgroundPage": (fn: Pointer): void => {
    72        A.store.Ref(fn, WEBEXT.extension.getBackgroundPage);
    73      },
    74      "call_GetBackgroundPage": (retPtr: Pointer): void => {
    75        const _ret = WEBEXT.extension.getBackgroundPage();
    76        A.store.Ref(retPtr, _ret);
    77      },
    78      "try_GetBackgroundPage": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    79        try {
    80          const _ret = WEBEXT.extension.getBackgroundPage();
    81          A.store.Ref(retPtr, _ret);
    82          return A.H.TRUE;
    83        } catch (err: any) {
    84          A.store.Ref(errPtr, err);
    85          return A.H.FALSE;
    86        }
    87      },
    88      "has_GetExtensionTabs": (): heap.Ref<boolean> => {
    89        if (WEBEXT?.extension && "getExtensionTabs" in WEBEXT?.extension) {
    90          return A.H.TRUE;
    91        }
    92        return A.H.FALSE;
    93      },
    94      "func_GetExtensionTabs": (fn: Pointer): void => {
    95        A.store.Ref(fn, WEBEXT.extension.getExtensionTabs);
    96      },
    97      "call_GetExtensionTabs": (retPtr: Pointer, windowId: number): void => {
    98        const _ret = WEBEXT.extension.getExtensionTabs(windowId);
    99        A.store.Ref(retPtr, _ret);
   100      },
   101      "try_GetExtensionTabs": (retPtr: Pointer, errPtr: Pointer, windowId: number): heap.Ref<boolean> => {
   102        try {
   103          const _ret = WEBEXT.extension.getExtensionTabs(windowId);
   104          A.store.Ref(retPtr, _ret);
   105          return A.H.TRUE;
   106        } catch (err: any) {
   107          A.store.Ref(errPtr, err);
   108          return A.H.FALSE;
   109        }
   110      },
   111      "has_GetURL": (): heap.Ref<boolean> => {
   112        if (WEBEXT?.extension && "getURL" in WEBEXT?.extension) {
   113          return A.H.TRUE;
   114        }
   115        return A.H.FALSE;
   116      },
   117      "func_GetURL": (fn: Pointer): void => {
   118        A.store.Ref(fn, WEBEXT.extension.getURL);
   119      },
   120      "call_GetURL": (retPtr: Pointer, path: heap.Ref<object>): void => {
   121        const _ret = WEBEXT.extension.getURL(A.H.get<object>(path));
   122        A.store.Ref(retPtr, _ret);
   123      },
   124      "try_GetURL": (retPtr: Pointer, errPtr: Pointer, path: heap.Ref<object>): heap.Ref<boolean> => {
   125        try {
   126          const _ret = WEBEXT.extension.getURL(A.H.get<object>(path));
   127          A.store.Ref(retPtr, _ret);
   128          return A.H.TRUE;
   129        } catch (err: any) {
   130          A.store.Ref(errPtr, err);
   131          return A.H.FALSE;
   132        }
   133      },
   134      "has_GetViews": (): heap.Ref<boolean> => {
   135        if (WEBEXT?.extension && "getViews" in WEBEXT?.extension) {
   136          return A.H.TRUE;
   137        }
   138        return A.H.FALSE;
   139      },
   140      "func_GetViews": (fn: Pointer): void => {
   141        A.store.Ref(fn, WEBEXT.extension.getViews);
   142      },
   143      "call_GetViews": (retPtr: Pointer, fetchProperties: Pointer): void => {
   144        const fetchProperties_ffi = {};
   145  
   146        if (A.load.Bool(fetchProperties + 24)) {
   147          fetchProperties_ffi["tabId"] = A.load.Int64(fetchProperties + 0);
   148        }
   149        fetchProperties_ffi["type"] = A.load.Enum(fetchProperties + 8, ["tab", "popup"]);
   150        if (A.load.Bool(fetchProperties + 25)) {
   151          fetchProperties_ffi["windowId"] = A.load.Int64(fetchProperties + 16);
   152        }
   153  
   154        const _ret = WEBEXT.extension.getViews(fetchProperties_ffi);
   155        A.store.Ref(retPtr, _ret);
   156      },
   157      "try_GetViews": (retPtr: Pointer, errPtr: Pointer, fetchProperties: Pointer): heap.Ref<boolean> => {
   158        try {
   159          const fetchProperties_ffi = {};
   160  
   161          if (A.load.Bool(fetchProperties + 24)) {
   162            fetchProperties_ffi["tabId"] = A.load.Int64(fetchProperties + 0);
   163          }
   164          fetchProperties_ffi["type"] = A.load.Enum(fetchProperties + 8, ["tab", "popup"]);
   165          if (A.load.Bool(fetchProperties + 25)) {
   166            fetchProperties_ffi["windowId"] = A.load.Int64(fetchProperties + 16);
   167          }
   168  
   169          const _ret = WEBEXT.extension.getViews(fetchProperties_ffi);
   170          A.store.Ref(retPtr, _ret);
   171          return A.H.TRUE;
   172        } catch (err: any) {
   173          A.store.Ref(errPtr, err);
   174          return A.H.FALSE;
   175        }
   176      },
   177      "get_InIncognitoContext": (retPtr: Pointer): heap.Ref<boolean> => {
   178        if (WEBEXT?.extension && "inIncognitoContext" in WEBEXT?.extension) {
   179          const val = WEBEXT.extension.inIncognitoContext;
   180          A.store.Bool(retPtr, val);
   181          return A.H.TRUE;
   182        }
   183  
   184        return A.H.FALSE;
   185      },
   186      "set_InIncognitoContext": (val: heap.Ref<boolean>): heap.Ref<boolean> => {
   187        return Reflect.set(WEBEXT.extension, "inIncognitoContext", val === A.H.TRUE, WEBEXT.extension)
   188          ? A.H.TRUE
   189          : A.H.FALSE;
   190      },
   191      "has_IsAllowedFileSchemeAccess": (): heap.Ref<boolean> => {
   192        if (WEBEXT?.extension && "isAllowedFileSchemeAccess" in WEBEXT?.extension) {
   193          return A.H.TRUE;
   194        }
   195        return A.H.FALSE;
   196      },
   197      "func_IsAllowedFileSchemeAccess": (fn: Pointer): void => {
   198        A.store.Ref(fn, WEBEXT.extension.isAllowedFileSchemeAccess);
   199      },
   200      "call_IsAllowedFileSchemeAccess": (retPtr: Pointer): void => {
   201        const _ret = WEBEXT.extension.isAllowedFileSchemeAccess();
   202        A.store.Ref(retPtr, _ret);
   203      },
   204      "try_IsAllowedFileSchemeAccess": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   205        try {
   206          const _ret = WEBEXT.extension.isAllowedFileSchemeAccess();
   207          A.store.Ref(retPtr, _ret);
   208          return A.H.TRUE;
   209        } catch (err: any) {
   210          A.store.Ref(errPtr, err);
   211          return A.H.FALSE;
   212        }
   213      },
   214      "has_IsAllowedIncognitoAccess": (): heap.Ref<boolean> => {
   215        if (WEBEXT?.extension && "isAllowedIncognitoAccess" in WEBEXT?.extension) {
   216          return A.H.TRUE;
   217        }
   218        return A.H.FALSE;
   219      },
   220      "func_IsAllowedIncognitoAccess": (fn: Pointer): void => {
   221        A.store.Ref(fn, WEBEXT.extension.isAllowedIncognitoAccess);
   222      },
   223      "call_IsAllowedIncognitoAccess": (retPtr: Pointer): void => {
   224        const _ret = WEBEXT.extension.isAllowedIncognitoAccess();
   225        A.store.Ref(retPtr, _ret);
   226      },
   227      "try_IsAllowedIncognitoAccess": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   228        try {
   229          const _ret = WEBEXT.extension.isAllowedIncognitoAccess();
   230          A.store.Ref(retPtr, _ret);
   231          return A.H.TRUE;
   232        } catch (err: any) {
   233          A.store.Ref(errPtr, err);
   234          return A.H.FALSE;
   235        }
   236      },
   237      "get_LastError": (retPtr: Pointer): heap.Ref<boolean> => {
   238        if (WEBEXT?.extension && "lastError" in WEBEXT?.extension) {
   239          const val = WEBEXT.extension.lastError;
   240          if (typeof val === "undefined") {
   241            A.store.Bool(retPtr + 4, false);
   242            A.store.Ref(retPtr + 0, undefined);
   243          } else {
   244            A.store.Bool(retPtr + 4, true);
   245            A.store.Ref(retPtr + 0, val["message"]);
   246          }
   247          return A.H.TRUE;
   248        }
   249  
   250        return A.H.FALSE;
   251      },
   252      "set_LastError": (val: Pointer): heap.Ref<boolean> => {
   253        const val_ffi = {};
   254  
   255        val_ffi["message"] = A.load.Ref(val + 0, undefined);
   256        return Reflect.set(WEBEXT.extension, "lastError", val_ffi, WEBEXT.extension) ? A.H.TRUE : A.H.FALSE;
   257      },
   258      "has_OnRequest": (): heap.Ref<boolean> => {
   259        if (WEBEXT?.extension?.onRequest && "addListener" in WEBEXT?.extension?.onRequest) {
   260          return A.H.TRUE;
   261        }
   262        return A.H.FALSE;
   263      },
   264      "func_OnRequest": (fn: Pointer): void => {
   265        A.store.Ref(fn, WEBEXT.extension.onRequest.addListener);
   266      },
   267      "call_OnRequest": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   268        const _ret = WEBEXT.extension.onRequest.addListener(A.H.get<object>(callback));
   269      },
   270      "try_OnRequest": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   271        try {
   272          const _ret = WEBEXT.extension.onRequest.addListener(A.H.get<object>(callback));
   273          return A.H.TRUE;
   274        } catch (err: any) {
   275          A.store.Ref(errPtr, err);
   276          return A.H.FALSE;
   277        }
   278      },
   279      "has_OffRequest": (): heap.Ref<boolean> => {
   280        if (WEBEXT?.extension?.onRequest && "removeListener" in WEBEXT?.extension?.onRequest) {
   281          return A.H.TRUE;
   282        }
   283        return A.H.FALSE;
   284      },
   285      "func_OffRequest": (fn: Pointer): void => {
   286        A.store.Ref(fn, WEBEXT.extension.onRequest.removeListener);
   287      },
   288      "call_OffRequest": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   289        const _ret = WEBEXT.extension.onRequest.removeListener(A.H.get<object>(callback));
   290      },
   291      "try_OffRequest": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   292        try {
   293          const _ret = WEBEXT.extension.onRequest.removeListener(A.H.get<object>(callback));
   294          return A.H.TRUE;
   295        } catch (err: any) {
   296          A.store.Ref(errPtr, err);
   297          return A.H.FALSE;
   298        }
   299      },
   300      "has_HasOnRequest": (): heap.Ref<boolean> => {
   301        if (WEBEXT?.extension?.onRequest && "hasListener" in WEBEXT?.extension?.onRequest) {
   302          return A.H.TRUE;
   303        }
   304        return A.H.FALSE;
   305      },
   306      "func_HasOnRequest": (fn: Pointer): void => {
   307        A.store.Ref(fn, WEBEXT.extension.onRequest.hasListener);
   308      },
   309      "call_HasOnRequest": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   310        const _ret = WEBEXT.extension.onRequest.hasListener(A.H.get<object>(callback));
   311        A.store.Bool(retPtr, _ret);
   312      },
   313      "try_HasOnRequest": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   314        try {
   315          const _ret = WEBEXT.extension.onRequest.hasListener(A.H.get<object>(callback));
   316          A.store.Bool(retPtr, _ret);
   317          return A.H.TRUE;
   318        } catch (err: any) {
   319          A.store.Ref(errPtr, err);
   320          return A.H.FALSE;
   321        }
   322      },
   323      "has_OnRequestExternal": (): heap.Ref<boolean> => {
   324        if (WEBEXT?.extension?.onRequestExternal && "addListener" in WEBEXT?.extension?.onRequestExternal) {
   325          return A.H.TRUE;
   326        }
   327        return A.H.FALSE;
   328      },
   329      "func_OnRequestExternal": (fn: Pointer): void => {
   330        A.store.Ref(fn, WEBEXT.extension.onRequestExternal.addListener);
   331      },
   332      "call_OnRequestExternal": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   333        const _ret = WEBEXT.extension.onRequestExternal.addListener(A.H.get<object>(callback));
   334      },
   335      "try_OnRequestExternal": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   336        try {
   337          const _ret = WEBEXT.extension.onRequestExternal.addListener(A.H.get<object>(callback));
   338          return A.H.TRUE;
   339        } catch (err: any) {
   340          A.store.Ref(errPtr, err);
   341          return A.H.FALSE;
   342        }
   343      },
   344      "has_OffRequestExternal": (): heap.Ref<boolean> => {
   345        if (WEBEXT?.extension?.onRequestExternal && "removeListener" in WEBEXT?.extension?.onRequestExternal) {
   346          return A.H.TRUE;
   347        }
   348        return A.H.FALSE;
   349      },
   350      "func_OffRequestExternal": (fn: Pointer): void => {
   351        A.store.Ref(fn, WEBEXT.extension.onRequestExternal.removeListener);
   352      },
   353      "call_OffRequestExternal": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   354        const _ret = WEBEXT.extension.onRequestExternal.removeListener(A.H.get<object>(callback));
   355      },
   356      "try_OffRequestExternal": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   357        try {
   358          const _ret = WEBEXT.extension.onRequestExternal.removeListener(A.H.get<object>(callback));
   359          return A.H.TRUE;
   360        } catch (err: any) {
   361          A.store.Ref(errPtr, err);
   362          return A.H.FALSE;
   363        }
   364      },
   365      "has_HasOnRequestExternal": (): heap.Ref<boolean> => {
   366        if (WEBEXT?.extension?.onRequestExternal && "hasListener" in WEBEXT?.extension?.onRequestExternal) {
   367          return A.H.TRUE;
   368        }
   369        return A.H.FALSE;
   370      },
   371      "func_HasOnRequestExternal": (fn: Pointer): void => {
   372        A.store.Ref(fn, WEBEXT.extension.onRequestExternal.hasListener);
   373      },
   374      "call_HasOnRequestExternal": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   375        const _ret = WEBEXT.extension.onRequestExternal.hasListener(A.H.get<object>(callback));
   376        A.store.Bool(retPtr, _ret);
   377      },
   378      "try_HasOnRequestExternal": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   379        try {
   380          const _ret = WEBEXT.extension.onRequestExternal.hasListener(A.H.get<object>(callback));
   381          A.store.Bool(retPtr, _ret);
   382          return A.H.TRUE;
   383        } catch (err: any) {
   384          A.store.Ref(errPtr, err);
   385          return A.H.FALSE;
   386        }
   387      },
   388      "has_SendRequest": (): heap.Ref<boolean> => {
   389        if (WEBEXT?.extension && "sendRequest" in WEBEXT?.extension) {
   390          return A.H.TRUE;
   391        }
   392        return A.H.FALSE;
   393      },
   394      "func_SendRequest": (fn: Pointer): void => {
   395        A.store.Ref(fn, WEBEXT.extension.sendRequest);
   396      },
   397      "call_SendRequest": (retPtr: Pointer, extensionId: heap.Ref<object>, request: heap.Ref<object>): void => {
   398        const _ret = WEBEXT.extension.sendRequest(A.H.get<object>(extensionId), A.H.get<object>(request));
   399        A.store.Ref(retPtr, _ret);
   400      },
   401      "try_SendRequest": (
   402        retPtr: Pointer,
   403        errPtr: Pointer,
   404        extensionId: heap.Ref<object>,
   405        request: heap.Ref<object>
   406      ): heap.Ref<boolean> => {
   407        try {
   408          const _ret = WEBEXT.extension.sendRequest(A.H.get<object>(extensionId), A.H.get<object>(request));
   409          A.store.Ref(retPtr, _ret);
   410          return A.H.TRUE;
   411        } catch (err: any) {
   412          A.store.Ref(errPtr, err);
   413          return A.H.FALSE;
   414        }
   415      },
   416      "has_SetUpdateUrlData": (): heap.Ref<boolean> => {
   417        if (WEBEXT?.extension && "setUpdateUrlData" in WEBEXT?.extension) {
   418          return A.H.TRUE;
   419        }
   420        return A.H.FALSE;
   421      },
   422      "func_SetUpdateUrlData": (fn: Pointer): void => {
   423        A.store.Ref(fn, WEBEXT.extension.setUpdateUrlData);
   424      },
   425      "call_SetUpdateUrlData": (retPtr: Pointer, data: heap.Ref<object>): void => {
   426        const _ret = WEBEXT.extension.setUpdateUrlData(A.H.get<object>(data));
   427      },
   428      "try_SetUpdateUrlData": (retPtr: Pointer, errPtr: Pointer, data: heap.Ref<object>): heap.Ref<boolean> => {
   429        try {
   430          const _ret = WEBEXT.extension.setUpdateUrlData(A.H.get<object>(data));
   431          return A.H.TRUE;
   432        } catch (err: any) {
   433          A.store.Ref(errPtr, err);
   434          return A.H.FALSE;
   435        }
   436      },
   437    };
   438  });