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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/storage", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "constof_AccessLevel": (ref: heap.Ref<string>): number => {
     8        const idx = ["TRUSTED_CONTEXTS", "TRUSTED_AND_UNTRUSTED_CONTEXTS"].indexOf(A.H.get(ref));
     9        return idx < 0 ? 0 : idx + 1;
    10      },
    11  
    12      "store_SetAccessLevelArgAccessOptions": (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 + 4, false);
    17          A.store.Enum(ptr + 0, -1);
    18        } else {
    19          A.store.Bool(ptr + 4, true);
    20          A.store.Enum(
    21            ptr + 0,
    22            ["TRUSTED_CONTEXTS", "TRUSTED_AND_UNTRUSTED_CONTEXTS"].indexOf(x["accessLevel"] as string)
    23          );
    24        }
    25      },
    26      "load_SetAccessLevelArgAccessOptions": (
    27        ptr: Pointer,
    28        create: heap.Ref<boolean>,
    29        ref: heap.Ref<any>
    30      ): heap.Ref<any> => {
    31        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    32  
    33        x["accessLevel"] = A.load.Enum(ptr + 0, ["TRUSTED_CONTEXTS", "TRUSTED_AND_UNTRUSTED_CONTEXTS"]);
    34        return create === A.H.TRUE ? A.H.push(x) : ref;
    35      },
    36  
    37      "has_StorageArea_Get": (self: heap.Ref<any>): heap.Ref<boolean> => {
    38        const obj = A.H.get<object>(self);
    39        if (obj && "get" in obj) {
    40          return A.H.TRUE;
    41        }
    42        return A.H.FALSE;
    43      },
    44      "func_StorageArea_Get": (self: heap.Ref<any>, fn: Pointer): void => {
    45        A.store.Ref(fn, A.H.get<any>(self).get);
    46      },
    47  
    48      "call_StorageArea_Get": (self: heap.Ref<object>, retPtr: Pointer, keys: heap.Ref<any>): void => {
    49        const thiz = A.H.get<any>(self);
    50  
    51        const _ret = thiz.get(A.H.get<any>(keys));
    52        A.store.Ref(retPtr, _ret);
    53      },
    54      "try_StorageArea_Get": (
    55        self: heap.Ref<object>,
    56        retPtr: Pointer,
    57        errPtr: Pointer,
    58        keys: heap.Ref<any>
    59      ): heap.Ref<boolean> => {
    60        try {
    61          const thiz = A.H.get<any>(self);
    62  
    63          const _ret = thiz.get(A.H.get<any>(keys));
    64          A.store.Ref(retPtr, _ret);
    65          return A.H.TRUE;
    66        } catch (err: any) {
    67          A.store.Ref(errPtr, err);
    68          return A.H.FALSE;
    69        }
    70      },
    71      "has_StorageArea_Get1": (self: heap.Ref<any>): heap.Ref<boolean> => {
    72        const obj = A.H.get<object>(self);
    73        if (obj && "get" in obj) {
    74          return A.H.TRUE;
    75        }
    76        return A.H.FALSE;
    77      },
    78      "func_StorageArea_Get1": (self: heap.Ref<any>, fn: Pointer): void => {
    79        A.store.Ref(fn, A.H.get<any>(self).get);
    80      },
    81  
    82      "call_StorageArea_Get1": (self: heap.Ref<object>, retPtr: Pointer): void => {
    83        const thiz = A.H.get<any>(self);
    84  
    85        const _ret = thiz.get();
    86        A.store.Ref(retPtr, _ret);
    87      },
    88      "try_StorageArea_Get1": (self: heap.Ref<object>, retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    89        try {
    90          const thiz = A.H.get<any>(self);
    91  
    92          const _ret = thiz.get();
    93          A.store.Ref(retPtr, _ret);
    94          return A.H.TRUE;
    95        } catch (err: any) {
    96          A.store.Ref(errPtr, err);
    97          return A.H.FALSE;
    98        }
    99      },
   100      "has_StorageArea_GetBytesInUse": (self: heap.Ref<any>): heap.Ref<boolean> => {
   101        const obj = A.H.get<object>(self);
   102        if (obj && "getBytesInUse" in obj) {
   103          return A.H.TRUE;
   104        }
   105        return A.H.FALSE;
   106      },
   107      "func_StorageArea_GetBytesInUse": (self: heap.Ref<any>, fn: Pointer): void => {
   108        A.store.Ref(fn, A.H.get<any>(self).getBytesInUse);
   109      },
   110  
   111      "call_StorageArea_GetBytesInUse": (self: heap.Ref<object>, retPtr: Pointer, keys: heap.Ref<any>): void => {
   112        const thiz = A.H.get<any>(self);
   113  
   114        const _ret = thiz.getBytesInUse(A.H.get<any>(keys));
   115        A.store.Ref(retPtr, _ret);
   116      },
   117      "try_StorageArea_GetBytesInUse": (
   118        self: heap.Ref<object>,
   119        retPtr: Pointer,
   120        errPtr: Pointer,
   121        keys: heap.Ref<any>
   122      ): heap.Ref<boolean> => {
   123        try {
   124          const thiz = A.H.get<any>(self);
   125  
   126          const _ret = thiz.getBytesInUse(A.H.get<any>(keys));
   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_StorageArea_GetBytesInUse1": (self: heap.Ref<any>): heap.Ref<boolean> => {
   135        const obj = A.H.get<object>(self);
   136        if (obj && "getBytesInUse" in obj) {
   137          return A.H.TRUE;
   138        }
   139        return A.H.FALSE;
   140      },
   141      "func_StorageArea_GetBytesInUse1": (self: heap.Ref<any>, fn: Pointer): void => {
   142        A.store.Ref(fn, A.H.get<any>(self).getBytesInUse);
   143      },
   144  
   145      "call_StorageArea_GetBytesInUse1": (self: heap.Ref<object>, retPtr: Pointer): void => {
   146        const thiz = A.H.get<any>(self);
   147  
   148        const _ret = thiz.getBytesInUse();
   149        A.store.Ref(retPtr, _ret);
   150      },
   151      "try_StorageArea_GetBytesInUse1": (self: heap.Ref<object>, retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   152        try {
   153          const thiz = A.H.get<any>(self);
   154  
   155          const _ret = thiz.getBytesInUse();
   156          A.store.Ref(retPtr, _ret);
   157          return A.H.TRUE;
   158        } catch (err: any) {
   159          A.store.Ref(errPtr, err);
   160          return A.H.FALSE;
   161        }
   162      },
   163      "has_StorageArea_Set": (self: heap.Ref<any>): heap.Ref<boolean> => {
   164        const obj = A.H.get<object>(self);
   165        if (obj && "set" in obj) {
   166          return A.H.TRUE;
   167        }
   168        return A.H.FALSE;
   169      },
   170      "func_StorageArea_Set": (self: heap.Ref<any>, fn: Pointer): void => {
   171        A.store.Ref(fn, A.H.get<any>(self).set);
   172      },
   173  
   174      "call_StorageArea_Set": (self: heap.Ref<object>, retPtr: Pointer, items: heap.Ref<object>): void => {
   175        const thiz = A.H.get<any>(self);
   176  
   177        const _ret = thiz.set(A.H.get<object>(items));
   178        A.store.Ref(retPtr, _ret);
   179      },
   180      "try_StorageArea_Set": (
   181        self: heap.Ref<object>,
   182        retPtr: Pointer,
   183        errPtr: Pointer,
   184        items: heap.Ref<object>
   185      ): heap.Ref<boolean> => {
   186        try {
   187          const thiz = A.H.get<any>(self);
   188  
   189          const _ret = thiz.set(A.H.get<object>(items));
   190          A.store.Ref(retPtr, _ret);
   191          return A.H.TRUE;
   192        } catch (err: any) {
   193          A.store.Ref(errPtr, err);
   194          return A.H.FALSE;
   195        }
   196      },
   197      "has_StorageArea_Remove": (self: heap.Ref<any>): heap.Ref<boolean> => {
   198        const obj = A.H.get<object>(self);
   199        if (obj && "remove" in obj) {
   200          return A.H.TRUE;
   201        }
   202        return A.H.FALSE;
   203      },
   204      "func_StorageArea_Remove": (self: heap.Ref<any>, fn: Pointer): void => {
   205        A.store.Ref(fn, A.H.get<any>(self).remove);
   206      },
   207  
   208      "call_StorageArea_Remove": (self: heap.Ref<object>, retPtr: Pointer, keys: heap.Ref<any>): void => {
   209        const thiz = A.H.get<any>(self);
   210  
   211        const _ret = thiz.remove(A.H.get<any>(keys));
   212        A.store.Ref(retPtr, _ret);
   213      },
   214      "try_StorageArea_Remove": (
   215        self: heap.Ref<object>,
   216        retPtr: Pointer,
   217        errPtr: Pointer,
   218        keys: heap.Ref<any>
   219      ): heap.Ref<boolean> => {
   220        try {
   221          const thiz = A.H.get<any>(self);
   222  
   223          const _ret = thiz.remove(A.H.get<any>(keys));
   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_StorageArea_Clear": (self: heap.Ref<any>): heap.Ref<boolean> => {
   232        const obj = A.H.get<object>(self);
   233        if (obj && "clear" in obj) {
   234          return A.H.TRUE;
   235        }
   236        return A.H.FALSE;
   237      },
   238      "func_StorageArea_Clear": (self: heap.Ref<any>, fn: Pointer): void => {
   239        A.store.Ref(fn, A.H.get<any>(self).clear);
   240      },
   241  
   242      "call_StorageArea_Clear": (self: heap.Ref<object>, retPtr: Pointer): void => {
   243        const thiz = A.H.get<any>(self);
   244  
   245        const _ret = thiz.clear();
   246        A.store.Ref(retPtr, _ret);
   247      },
   248      "try_StorageArea_Clear": (self: heap.Ref<object>, retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   249        try {
   250          const thiz = A.H.get<any>(self);
   251  
   252          const _ret = thiz.clear();
   253          A.store.Ref(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_StorageArea_SetAccessLevel": (self: heap.Ref<any>): heap.Ref<boolean> => {
   261        const obj = A.H.get<object>(self);
   262        if (obj && "setAccessLevel" in obj) {
   263          return A.H.TRUE;
   264        }
   265        return A.H.FALSE;
   266      },
   267      "func_StorageArea_SetAccessLevel": (self: heap.Ref<any>, fn: Pointer): void => {
   268        A.store.Ref(fn, A.H.get<any>(self).setAccessLevel);
   269      },
   270  
   271      "call_StorageArea_SetAccessLevel": (self: heap.Ref<object>, retPtr: Pointer, accessOptions: Pointer): void => {
   272        const thiz = A.H.get<any>(self);
   273  
   274        const accessOptions_ffi = {};
   275  
   276        accessOptions_ffi["accessLevel"] = A.load.Enum(accessOptions + 0, [
   277          "TRUSTED_CONTEXTS",
   278          "TRUSTED_AND_UNTRUSTED_CONTEXTS",
   279        ]);
   280        const _ret = thiz.setAccessLevel(accessOptions_ffi);
   281        A.store.Ref(retPtr, _ret);
   282      },
   283      "try_StorageArea_SetAccessLevel": (
   284        self: heap.Ref<object>,
   285        retPtr: Pointer,
   286        errPtr: Pointer,
   287        accessOptions: Pointer
   288      ): heap.Ref<boolean> => {
   289        try {
   290          const thiz = A.H.get<any>(self);
   291  
   292          const accessOptions_ffi = {};
   293  
   294          accessOptions_ffi["accessLevel"] = A.load.Enum(accessOptions + 0, [
   295            "TRUSTED_CONTEXTS",
   296            "TRUSTED_AND_UNTRUSTED_CONTEXTS",
   297          ]);
   298          const _ret = thiz.setAccessLevel(accessOptions_ffi);
   299          A.store.Ref(retPtr, _ret);
   300          return A.H.TRUE;
   301        } catch (err: any) {
   302          A.store.Ref(errPtr, err);
   303          return A.H.FALSE;
   304        }
   305      },
   306  
   307      "store_StorageChange": (ptr: Pointer, ref: heap.Ref<any>) => {
   308        const x = A.H.get<any>(ref);
   309  
   310        if (typeof x === "undefined") {
   311          A.store.Bool(ptr + 8, false);
   312          A.store.Ref(ptr + 0, undefined);
   313          A.store.Ref(ptr + 4, undefined);
   314        } else {
   315          A.store.Bool(ptr + 8, true);
   316          A.store.Ref(ptr + 0, x["newValue"]);
   317          A.store.Ref(ptr + 4, x["oldValue"]);
   318        }
   319      },
   320      "load_StorageChange": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   321        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   322  
   323        x["newValue"] = A.load.Ref(ptr + 0, undefined);
   324        x["oldValue"] = A.load.Ref(ptr + 4, undefined);
   325        return create === A.H.TRUE ? A.H.push(x) : ref;
   326      },
   327      "get_Local": (retPtr: Pointer): heap.Ref<boolean> => {
   328        if (WEBEXT?.storage && "local" in WEBEXT?.storage) {
   329          const val = WEBEXT.storage.local;
   330          A.store.Ref(retPtr, val);
   331          return A.H.TRUE;
   332        }
   333  
   334        return A.H.FALSE;
   335      },
   336      "set_Local": (val: heap.Ref<object>): heap.Ref<boolean> => {
   337        return Reflect.set(WEBEXT.storage, "local", A.H.get<object>(val), WEBEXT.storage) ? A.H.TRUE : A.H.FALSE;
   338      },
   339      "get_Managed": (retPtr: Pointer): heap.Ref<boolean> => {
   340        if (WEBEXT?.storage && "managed" in WEBEXT?.storage) {
   341          const val = WEBEXT.storage.managed;
   342          A.store.Ref(retPtr, val);
   343          return A.H.TRUE;
   344        }
   345  
   346        return A.H.FALSE;
   347      },
   348      "set_Managed": (val: heap.Ref<object>): heap.Ref<boolean> => {
   349        return Reflect.set(WEBEXT.storage, "managed", A.H.get<object>(val), WEBEXT.storage) ? A.H.TRUE : A.H.FALSE;
   350      },
   351      "has_OnChanged": (): heap.Ref<boolean> => {
   352        if (WEBEXT?.storage?.onChanged && "addListener" in WEBEXT?.storage?.onChanged) {
   353          return A.H.TRUE;
   354        }
   355        return A.H.FALSE;
   356      },
   357      "func_OnChanged": (fn: Pointer): void => {
   358        A.store.Ref(fn, WEBEXT.storage.onChanged.addListener);
   359      },
   360      "call_OnChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   361        const _ret = WEBEXT.storage.onChanged.addListener(A.H.get<object>(callback));
   362      },
   363      "try_OnChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   364        try {
   365          const _ret = WEBEXT.storage.onChanged.addListener(A.H.get<object>(callback));
   366          return A.H.TRUE;
   367        } catch (err: any) {
   368          A.store.Ref(errPtr, err);
   369          return A.H.FALSE;
   370        }
   371      },
   372      "has_OffChanged": (): heap.Ref<boolean> => {
   373        if (WEBEXT?.storage?.onChanged && "removeListener" in WEBEXT?.storage?.onChanged) {
   374          return A.H.TRUE;
   375        }
   376        return A.H.FALSE;
   377      },
   378      "func_OffChanged": (fn: Pointer): void => {
   379        A.store.Ref(fn, WEBEXT.storage.onChanged.removeListener);
   380      },
   381      "call_OffChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   382        const _ret = WEBEXT.storage.onChanged.removeListener(A.H.get<object>(callback));
   383      },
   384      "try_OffChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   385        try {
   386          const _ret = WEBEXT.storage.onChanged.removeListener(A.H.get<object>(callback));
   387          return A.H.TRUE;
   388        } catch (err: any) {
   389          A.store.Ref(errPtr, err);
   390          return A.H.FALSE;
   391        }
   392      },
   393      "has_HasOnChanged": (): heap.Ref<boolean> => {
   394        if (WEBEXT?.storage?.onChanged && "hasListener" in WEBEXT?.storage?.onChanged) {
   395          return A.H.TRUE;
   396        }
   397        return A.H.FALSE;
   398      },
   399      "func_HasOnChanged": (fn: Pointer): void => {
   400        A.store.Ref(fn, WEBEXT.storage.onChanged.hasListener);
   401      },
   402      "call_HasOnChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   403        const _ret = WEBEXT.storage.onChanged.hasListener(A.H.get<object>(callback));
   404        A.store.Bool(retPtr, _ret);
   405      },
   406      "try_HasOnChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   407        try {
   408          const _ret = WEBEXT.storage.onChanged.hasListener(A.H.get<object>(callback));
   409          A.store.Bool(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      "get_Session": (retPtr: Pointer): heap.Ref<boolean> => {
   417        if (WEBEXT?.storage && "session" in WEBEXT?.storage) {
   418          const val = WEBEXT.storage.session;
   419          A.store.Ref(retPtr, val);
   420          return A.H.TRUE;
   421        }
   422  
   423        return A.H.FALSE;
   424      },
   425      "set_Session": (val: heap.Ref<object>): heap.Ref<boolean> => {
   426        return Reflect.set(WEBEXT.storage, "session", A.H.get<object>(val), WEBEXT.storage) ? A.H.TRUE : A.H.FALSE;
   427      },
   428      "get_Sync": (retPtr: Pointer): heap.Ref<boolean> => {
   429        if (WEBEXT?.storage && "sync" in WEBEXT?.storage) {
   430          const val = WEBEXT.storage.sync;
   431          A.store.Ref(retPtr, val);
   432          return A.H.TRUE;
   433        }
   434  
   435        return A.H.FALSE;
   436      },
   437      "set_Sync": (val: heap.Ref<object>): heap.Ref<boolean> => {
   438        return Reflect.set(WEBEXT.storage, "sync", A.H.get<object>(val), WEBEXT.storage) ? A.H.TRUE : A.H.FALSE;
   439      },
   440    };
   441  });