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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/permissions", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_Permissions": (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 + 8, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14        } else {
    15          A.store.Bool(ptr + 8, true);
    16          A.store.Ref(ptr + 0, x["origins"]);
    17          A.store.Ref(ptr + 4, x["permissions"]);
    18        }
    19      },
    20      "load_Permissions": (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        x["origins"] = A.load.Ref(ptr + 0, undefined);
    24        x["permissions"] = A.load.Ref(ptr + 4, undefined);
    25        return create === A.H.TRUE ? A.H.push(x) : ref;
    26      },
    27      "has_Contains": (): heap.Ref<boolean> => {
    28        if (WEBEXT?.permissions && "contains" in WEBEXT?.permissions) {
    29          return A.H.TRUE;
    30        }
    31        return A.H.FALSE;
    32      },
    33      "func_Contains": (fn: Pointer): void => {
    34        A.store.Ref(fn, WEBEXT.permissions.contains);
    35      },
    36      "call_Contains": (retPtr: Pointer, permissions: Pointer): void => {
    37        const permissions_ffi = {};
    38  
    39        permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined);
    40        permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined);
    41  
    42        const _ret = WEBEXT.permissions.contains(permissions_ffi);
    43        A.store.Ref(retPtr, _ret);
    44      },
    45      "try_Contains": (retPtr: Pointer, errPtr: Pointer, permissions: Pointer): heap.Ref<boolean> => {
    46        try {
    47          const permissions_ffi = {};
    48  
    49          permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined);
    50          permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined);
    51  
    52          const _ret = WEBEXT.permissions.contains(permissions_ffi);
    53          A.store.Ref(retPtr, _ret);
    54          return A.H.TRUE;
    55        } catch (err: any) {
    56          A.store.Ref(errPtr, err);
    57          return A.H.FALSE;
    58        }
    59      },
    60      "has_GetAll": (): heap.Ref<boolean> => {
    61        if (WEBEXT?.permissions && "getAll" in WEBEXT?.permissions) {
    62          return A.H.TRUE;
    63        }
    64        return A.H.FALSE;
    65      },
    66      "func_GetAll": (fn: Pointer): void => {
    67        A.store.Ref(fn, WEBEXT.permissions.getAll);
    68      },
    69      "call_GetAll": (retPtr: Pointer): void => {
    70        const _ret = WEBEXT.permissions.getAll();
    71        A.store.Ref(retPtr, _ret);
    72      },
    73      "try_GetAll": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    74        try {
    75          const _ret = WEBEXT.permissions.getAll();
    76          A.store.Ref(retPtr, _ret);
    77          return A.H.TRUE;
    78        } catch (err: any) {
    79          A.store.Ref(errPtr, err);
    80          return A.H.FALSE;
    81        }
    82      },
    83      "has_OnAdded": (): heap.Ref<boolean> => {
    84        if (WEBEXT?.permissions?.onAdded && "addListener" in WEBEXT?.permissions?.onAdded) {
    85          return A.H.TRUE;
    86        }
    87        return A.H.FALSE;
    88      },
    89      "func_OnAdded": (fn: Pointer): void => {
    90        A.store.Ref(fn, WEBEXT.permissions.onAdded.addListener);
    91      },
    92      "call_OnAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => {
    93        const _ret = WEBEXT.permissions.onAdded.addListener(A.H.get<object>(callback));
    94      },
    95      "try_OnAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
    96        try {
    97          const _ret = WEBEXT.permissions.onAdded.addListener(A.H.get<object>(callback));
    98          return A.H.TRUE;
    99        } catch (err: any) {
   100          A.store.Ref(errPtr, err);
   101          return A.H.FALSE;
   102        }
   103      },
   104      "has_OffAdded": (): heap.Ref<boolean> => {
   105        if (WEBEXT?.permissions?.onAdded && "removeListener" in WEBEXT?.permissions?.onAdded) {
   106          return A.H.TRUE;
   107        }
   108        return A.H.FALSE;
   109      },
   110      "func_OffAdded": (fn: Pointer): void => {
   111        A.store.Ref(fn, WEBEXT.permissions.onAdded.removeListener);
   112      },
   113      "call_OffAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   114        const _ret = WEBEXT.permissions.onAdded.removeListener(A.H.get<object>(callback));
   115      },
   116      "try_OffAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   117        try {
   118          const _ret = WEBEXT.permissions.onAdded.removeListener(A.H.get<object>(callback));
   119          return A.H.TRUE;
   120        } catch (err: any) {
   121          A.store.Ref(errPtr, err);
   122          return A.H.FALSE;
   123        }
   124      },
   125      "has_HasOnAdded": (): heap.Ref<boolean> => {
   126        if (WEBEXT?.permissions?.onAdded && "hasListener" in WEBEXT?.permissions?.onAdded) {
   127          return A.H.TRUE;
   128        }
   129        return A.H.FALSE;
   130      },
   131      "func_HasOnAdded": (fn: Pointer): void => {
   132        A.store.Ref(fn, WEBEXT.permissions.onAdded.hasListener);
   133      },
   134      "call_HasOnAdded": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   135        const _ret = WEBEXT.permissions.onAdded.hasListener(A.H.get<object>(callback));
   136        A.store.Bool(retPtr, _ret);
   137      },
   138      "try_HasOnAdded": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   139        try {
   140          const _ret = WEBEXT.permissions.onAdded.hasListener(A.H.get<object>(callback));
   141          A.store.Bool(retPtr, _ret);
   142          return A.H.TRUE;
   143        } catch (err: any) {
   144          A.store.Ref(errPtr, err);
   145          return A.H.FALSE;
   146        }
   147      },
   148      "has_OnRemoved": (): heap.Ref<boolean> => {
   149        if (WEBEXT?.permissions?.onRemoved && "addListener" in WEBEXT?.permissions?.onRemoved) {
   150          return A.H.TRUE;
   151        }
   152        return A.H.FALSE;
   153      },
   154      "func_OnRemoved": (fn: Pointer): void => {
   155        A.store.Ref(fn, WEBEXT.permissions.onRemoved.addListener);
   156      },
   157      "call_OnRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   158        const _ret = WEBEXT.permissions.onRemoved.addListener(A.H.get<object>(callback));
   159      },
   160      "try_OnRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   161        try {
   162          const _ret = WEBEXT.permissions.onRemoved.addListener(A.H.get<object>(callback));
   163          return A.H.TRUE;
   164        } catch (err: any) {
   165          A.store.Ref(errPtr, err);
   166          return A.H.FALSE;
   167        }
   168      },
   169      "has_OffRemoved": (): heap.Ref<boolean> => {
   170        if (WEBEXT?.permissions?.onRemoved && "removeListener" in WEBEXT?.permissions?.onRemoved) {
   171          return A.H.TRUE;
   172        }
   173        return A.H.FALSE;
   174      },
   175      "func_OffRemoved": (fn: Pointer): void => {
   176        A.store.Ref(fn, WEBEXT.permissions.onRemoved.removeListener);
   177      },
   178      "call_OffRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   179        const _ret = WEBEXT.permissions.onRemoved.removeListener(A.H.get<object>(callback));
   180      },
   181      "try_OffRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   182        try {
   183          const _ret = WEBEXT.permissions.onRemoved.removeListener(A.H.get<object>(callback));
   184          return A.H.TRUE;
   185        } catch (err: any) {
   186          A.store.Ref(errPtr, err);
   187          return A.H.FALSE;
   188        }
   189      },
   190      "has_HasOnRemoved": (): heap.Ref<boolean> => {
   191        if (WEBEXT?.permissions?.onRemoved && "hasListener" in WEBEXT?.permissions?.onRemoved) {
   192          return A.H.TRUE;
   193        }
   194        return A.H.FALSE;
   195      },
   196      "func_HasOnRemoved": (fn: Pointer): void => {
   197        A.store.Ref(fn, WEBEXT.permissions.onRemoved.hasListener);
   198      },
   199      "call_HasOnRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   200        const _ret = WEBEXT.permissions.onRemoved.hasListener(A.H.get<object>(callback));
   201        A.store.Bool(retPtr, _ret);
   202      },
   203      "try_HasOnRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   204        try {
   205          const _ret = WEBEXT.permissions.onRemoved.hasListener(A.H.get<object>(callback));
   206          A.store.Bool(retPtr, _ret);
   207          return A.H.TRUE;
   208        } catch (err: any) {
   209          A.store.Ref(errPtr, err);
   210          return A.H.FALSE;
   211        }
   212      },
   213      "has_Remove": (): heap.Ref<boolean> => {
   214        if (WEBEXT?.permissions && "remove" in WEBEXT?.permissions) {
   215          return A.H.TRUE;
   216        }
   217        return A.H.FALSE;
   218      },
   219      "func_Remove": (fn: Pointer): void => {
   220        A.store.Ref(fn, WEBEXT.permissions.remove);
   221      },
   222      "call_Remove": (retPtr: Pointer, permissions: Pointer): void => {
   223        const permissions_ffi = {};
   224  
   225        permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined);
   226        permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined);
   227  
   228        const _ret = WEBEXT.permissions.remove(permissions_ffi);
   229        A.store.Ref(retPtr, _ret);
   230      },
   231      "try_Remove": (retPtr: Pointer, errPtr: Pointer, permissions: Pointer): heap.Ref<boolean> => {
   232        try {
   233          const permissions_ffi = {};
   234  
   235          permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined);
   236          permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined);
   237  
   238          const _ret = WEBEXT.permissions.remove(permissions_ffi);
   239          A.store.Ref(retPtr, _ret);
   240          return A.H.TRUE;
   241        } catch (err: any) {
   242          A.store.Ref(errPtr, err);
   243          return A.H.FALSE;
   244        }
   245      },
   246      "has_Request": (): heap.Ref<boolean> => {
   247        if (WEBEXT?.permissions && "request" in WEBEXT?.permissions) {
   248          return A.H.TRUE;
   249        }
   250        return A.H.FALSE;
   251      },
   252      "func_Request": (fn: Pointer): void => {
   253        A.store.Ref(fn, WEBEXT.permissions.request);
   254      },
   255      "call_Request": (retPtr: Pointer, permissions: Pointer): void => {
   256        const permissions_ffi = {};
   257  
   258        permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined);
   259        permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined);
   260  
   261        const _ret = WEBEXT.permissions.request(permissions_ffi);
   262        A.store.Ref(retPtr, _ret);
   263      },
   264      "try_Request": (retPtr: Pointer, errPtr: Pointer, permissions: Pointer): heap.Ref<boolean> => {
   265        try {
   266          const permissions_ffi = {};
   267  
   268          permissions_ffi["origins"] = A.load.Ref(permissions + 0, undefined);
   269          permissions_ffi["permissions"] = A.load.Ref(permissions + 4, undefined);
   270  
   271          const _ret = WEBEXT.permissions.request(permissions_ffi);
   272          A.store.Ref(retPtr, _ret);
   273          return A.H.TRUE;
   274        } catch (err: any) {
   275          A.store.Ref(errPtr, err);
   276          return A.H.FALSE;
   277        }
   278      },
   279    };
   280  });