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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/loginstate", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "constof_ProfileType": (ref: heap.Ref<string>): number => {
     8        const idx = ["SIGNIN_PROFILE", "USER_PROFILE"].indexOf(A.H.get(ref));
     9        return idx < 0 ? 0 : idx + 1;
    10      },
    11      "constof_SessionState": (ref: heap.Ref<string>): number => {
    12        const idx = [
    13          "UNKNOWN",
    14          "IN_OOBE_SCREEN",
    15          "IN_LOGIN_SCREEN",
    16          "IN_SESSION",
    17          "IN_LOCK_SCREEN",
    18          "IN_RMA_SCREEN",
    19        ].indexOf(A.H.get(ref));
    20        return idx < 0 ? 0 : idx + 1;
    21      },
    22      "has_GetProfileType": (): heap.Ref<boolean> => {
    23        if (WEBEXT?.loginState && "getProfileType" in WEBEXT?.loginState) {
    24          return A.H.TRUE;
    25        }
    26        return A.H.FALSE;
    27      },
    28      "func_GetProfileType": (fn: Pointer): void => {
    29        A.store.Ref(fn, WEBEXT.loginState.getProfileType);
    30      },
    31      "call_GetProfileType": (retPtr: Pointer): void => {
    32        const _ret = WEBEXT.loginState.getProfileType();
    33        A.store.Ref(retPtr, _ret);
    34      },
    35      "try_GetProfileType": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    36        try {
    37          const _ret = WEBEXT.loginState.getProfileType();
    38          A.store.Ref(retPtr, _ret);
    39          return A.H.TRUE;
    40        } catch (err: any) {
    41          A.store.Ref(errPtr, err);
    42          return A.H.FALSE;
    43        }
    44      },
    45      "has_GetSessionState": (): heap.Ref<boolean> => {
    46        if (WEBEXT?.loginState && "getSessionState" in WEBEXT?.loginState) {
    47          return A.H.TRUE;
    48        }
    49        return A.H.FALSE;
    50      },
    51      "func_GetSessionState": (fn: Pointer): void => {
    52        A.store.Ref(fn, WEBEXT.loginState.getSessionState);
    53      },
    54      "call_GetSessionState": (retPtr: Pointer): void => {
    55        const _ret = WEBEXT.loginState.getSessionState();
    56        A.store.Ref(retPtr, _ret);
    57      },
    58      "try_GetSessionState": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    59        try {
    60          const _ret = WEBEXT.loginState.getSessionState();
    61          A.store.Ref(retPtr, _ret);
    62          return A.H.TRUE;
    63        } catch (err: any) {
    64          A.store.Ref(errPtr, err);
    65          return A.H.FALSE;
    66        }
    67      },
    68      "has_OnSessionStateChanged": (): heap.Ref<boolean> => {
    69        if (WEBEXT?.loginState?.onSessionStateChanged && "addListener" in WEBEXT?.loginState?.onSessionStateChanged) {
    70          return A.H.TRUE;
    71        }
    72        return A.H.FALSE;
    73      },
    74      "func_OnSessionStateChanged": (fn: Pointer): void => {
    75        A.store.Ref(fn, WEBEXT.loginState.onSessionStateChanged.addListener);
    76      },
    77      "call_OnSessionStateChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
    78        const _ret = WEBEXT.loginState.onSessionStateChanged.addListener(A.H.get<object>(callback));
    79      },
    80      "try_OnSessionStateChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
    81        try {
    82          const _ret = WEBEXT.loginState.onSessionStateChanged.addListener(A.H.get<object>(callback));
    83          return A.H.TRUE;
    84        } catch (err: any) {
    85          A.store.Ref(errPtr, err);
    86          return A.H.FALSE;
    87        }
    88      },
    89      "has_OffSessionStateChanged": (): heap.Ref<boolean> => {
    90        if (WEBEXT?.loginState?.onSessionStateChanged && "removeListener" in WEBEXT?.loginState?.onSessionStateChanged) {
    91          return A.H.TRUE;
    92        }
    93        return A.H.FALSE;
    94      },
    95      "func_OffSessionStateChanged": (fn: Pointer): void => {
    96        A.store.Ref(fn, WEBEXT.loginState.onSessionStateChanged.removeListener);
    97      },
    98      "call_OffSessionStateChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
    99        const _ret = WEBEXT.loginState.onSessionStateChanged.removeListener(A.H.get<object>(callback));
   100      },
   101      "try_OffSessionStateChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   102        try {
   103          const _ret = WEBEXT.loginState.onSessionStateChanged.removeListener(A.H.get<object>(callback));
   104          return A.H.TRUE;
   105        } catch (err: any) {
   106          A.store.Ref(errPtr, err);
   107          return A.H.FALSE;
   108        }
   109      },
   110      "has_HasOnSessionStateChanged": (): heap.Ref<boolean> => {
   111        if (WEBEXT?.loginState?.onSessionStateChanged && "hasListener" in WEBEXT?.loginState?.onSessionStateChanged) {
   112          return A.H.TRUE;
   113        }
   114        return A.H.FALSE;
   115      },
   116      "func_HasOnSessionStateChanged": (fn: Pointer): void => {
   117        A.store.Ref(fn, WEBEXT.loginState.onSessionStateChanged.hasListener);
   118      },
   119      "call_HasOnSessionStateChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   120        const _ret = WEBEXT.loginState.onSessionStateChanged.hasListener(A.H.get<object>(callback));
   121        A.store.Bool(retPtr, _ret);
   122      },
   123      "try_HasOnSessionStateChanged": (
   124        retPtr: Pointer,
   125        errPtr: Pointer,
   126        callback: heap.Ref<object>
   127      ): heap.Ref<boolean> => {
   128        try {
   129          const _ret = WEBEXT.loginState.onSessionStateChanged.hasListener(A.H.get<object>(callback));
   130          A.store.Bool(retPtr, _ret);
   131          return A.H.TRUE;
   132        } catch (err: any) {
   133          A.store.Ref(errPtr, err);
   134          return A.H.FALSE;
   135        }
   136      },
   137    };
   138  });