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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/loginscreenstorage", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "has_RetrieveCredentials": (): heap.Ref<boolean> => {
     8        if (WEBEXT?.loginScreenStorage && "retrieveCredentials" in WEBEXT?.loginScreenStorage) {
     9          return A.H.TRUE;
    10        }
    11        return A.H.FALSE;
    12      },
    13      "func_RetrieveCredentials": (fn: Pointer): void => {
    14        A.store.Ref(fn, WEBEXT.loginScreenStorage.retrieveCredentials);
    15      },
    16      "call_RetrieveCredentials": (retPtr: Pointer): void => {
    17        const _ret = WEBEXT.loginScreenStorage.retrieveCredentials();
    18        A.store.Ref(retPtr, _ret);
    19      },
    20      "try_RetrieveCredentials": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    21        try {
    22          const _ret = WEBEXT.loginScreenStorage.retrieveCredentials();
    23          A.store.Ref(retPtr, _ret);
    24          return A.H.TRUE;
    25        } catch (err: any) {
    26          A.store.Ref(errPtr, err);
    27          return A.H.FALSE;
    28        }
    29      },
    30      "has_RetrievePersistentData": (): heap.Ref<boolean> => {
    31        if (WEBEXT?.loginScreenStorage && "retrievePersistentData" in WEBEXT?.loginScreenStorage) {
    32          return A.H.TRUE;
    33        }
    34        return A.H.FALSE;
    35      },
    36      "func_RetrievePersistentData": (fn: Pointer): void => {
    37        A.store.Ref(fn, WEBEXT.loginScreenStorage.retrievePersistentData);
    38      },
    39      "call_RetrievePersistentData": (retPtr: Pointer, ownerId: heap.Ref<object>): void => {
    40        const _ret = WEBEXT.loginScreenStorage.retrievePersistentData(A.H.get<object>(ownerId));
    41        A.store.Ref(retPtr, _ret);
    42      },
    43      "try_RetrievePersistentData": (retPtr: Pointer, errPtr: Pointer, ownerId: heap.Ref<object>): heap.Ref<boolean> => {
    44        try {
    45          const _ret = WEBEXT.loginScreenStorage.retrievePersistentData(A.H.get<object>(ownerId));
    46          A.store.Ref(retPtr, _ret);
    47          return A.H.TRUE;
    48        } catch (err: any) {
    49          A.store.Ref(errPtr, err);
    50          return A.H.FALSE;
    51        }
    52      },
    53      "has_StoreCredentials": (): heap.Ref<boolean> => {
    54        if (WEBEXT?.loginScreenStorage && "storeCredentials" in WEBEXT?.loginScreenStorage) {
    55          return A.H.TRUE;
    56        }
    57        return A.H.FALSE;
    58      },
    59      "func_StoreCredentials": (fn: Pointer): void => {
    60        A.store.Ref(fn, WEBEXT.loginScreenStorage.storeCredentials);
    61      },
    62      "call_StoreCredentials": (retPtr: Pointer, extensionId: heap.Ref<object>, credentials: heap.Ref<object>): void => {
    63        const _ret = WEBEXT.loginScreenStorage.storeCredentials(
    64          A.H.get<object>(extensionId),
    65          A.H.get<object>(credentials)
    66        );
    67        A.store.Ref(retPtr, _ret);
    68      },
    69      "try_StoreCredentials": (
    70        retPtr: Pointer,
    71        errPtr: Pointer,
    72        extensionId: heap.Ref<object>,
    73        credentials: heap.Ref<object>
    74      ): heap.Ref<boolean> => {
    75        try {
    76          const _ret = WEBEXT.loginScreenStorage.storeCredentials(
    77            A.H.get<object>(extensionId),
    78            A.H.get<object>(credentials)
    79          );
    80          A.store.Ref(retPtr, _ret);
    81          return A.H.TRUE;
    82        } catch (err: any) {
    83          A.store.Ref(errPtr, err);
    84          return A.H.FALSE;
    85        }
    86      },
    87      "has_StorePersistentData": (): heap.Ref<boolean> => {
    88        if (WEBEXT?.loginScreenStorage && "storePersistentData" in WEBEXT?.loginScreenStorage) {
    89          return A.H.TRUE;
    90        }
    91        return A.H.FALSE;
    92      },
    93      "func_StorePersistentData": (fn: Pointer): void => {
    94        A.store.Ref(fn, WEBEXT.loginScreenStorage.storePersistentData);
    95      },
    96      "call_StorePersistentData": (retPtr: Pointer, extensionIds: heap.Ref<object>, data: heap.Ref<object>): void => {
    97        const _ret = WEBEXT.loginScreenStorage.storePersistentData(A.H.get<object>(extensionIds), A.H.get<object>(data));
    98        A.store.Ref(retPtr, _ret);
    99      },
   100      "try_StorePersistentData": (
   101        retPtr: Pointer,
   102        errPtr: Pointer,
   103        extensionIds: heap.Ref<object>,
   104        data: heap.Ref<object>
   105      ): heap.Ref<boolean> => {
   106        try {
   107          const _ret = WEBEXT.loginScreenStorage.storePersistentData(
   108            A.H.get<object>(extensionIds),
   109            A.H.get<object>(data)
   110          );
   111          A.store.Ref(retPtr, _ret);
   112          return A.H.TRUE;
   113        } catch (err: any) {
   114          A.store.Ref(errPtr, err);
   115          return A.H.FALSE;
   116        }
   117      },
   118    };
   119  });