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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/alarms", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_Alarm": (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 + 26, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Bool(ptr + 24, false);
    14          A.store.Float64(ptr + 8, 0);
    15          A.store.Bool(ptr + 25, false);
    16          A.store.Float64(ptr + 16, 0);
    17        } else {
    18          A.store.Bool(ptr + 26, true);
    19          A.store.Ref(ptr + 0, x["name"]);
    20          A.store.Bool(ptr + 24, "scheduledTime" in x ? true : false);
    21          A.store.Float64(ptr + 8, x["scheduledTime"] === undefined ? 0 : (x["scheduledTime"] as number));
    22          A.store.Bool(ptr + 25, "periodInMinutes" in x ? true : false);
    23          A.store.Float64(ptr + 16, x["periodInMinutes"] === undefined ? 0 : (x["periodInMinutes"] as number));
    24        }
    25      },
    26      "load_Alarm": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    27        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    28  
    29        x["name"] = A.load.Ref(ptr + 0, undefined);
    30        if (A.load.Bool(ptr + 24)) {
    31          x["scheduledTime"] = A.load.Float64(ptr + 8);
    32        } else {
    33          delete x["scheduledTime"];
    34        }
    35        if (A.load.Bool(ptr + 25)) {
    36          x["periodInMinutes"] = A.load.Float64(ptr + 16);
    37        } else {
    38          delete x["periodInMinutes"];
    39        }
    40        return create === A.H.TRUE ? A.H.push(x) : ref;
    41      },
    42  
    43      "store_AlarmCreateInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    44        const x = A.H.get<any>(ref);
    45  
    46        if (typeof x === "undefined") {
    47          A.store.Bool(ptr + 27, false);
    48          A.store.Bool(ptr + 24, false);
    49          A.store.Float64(ptr + 0, 0);
    50          A.store.Bool(ptr + 25, false);
    51          A.store.Float64(ptr + 8, 0);
    52          A.store.Bool(ptr + 26, false);
    53          A.store.Float64(ptr + 16, 0);
    54        } else {
    55          A.store.Bool(ptr + 27, true);
    56          A.store.Bool(ptr + 24, "when" in x ? true : false);
    57          A.store.Float64(ptr + 0, x["when"] === undefined ? 0 : (x["when"] as number));
    58          A.store.Bool(ptr + 25, "delayInMinutes" in x ? true : false);
    59          A.store.Float64(ptr + 8, x["delayInMinutes"] === undefined ? 0 : (x["delayInMinutes"] as number));
    60          A.store.Bool(ptr + 26, "periodInMinutes" in x ? true : false);
    61          A.store.Float64(ptr + 16, x["periodInMinutes"] === undefined ? 0 : (x["periodInMinutes"] as number));
    62        }
    63      },
    64      "load_AlarmCreateInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    65        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    66  
    67        if (A.load.Bool(ptr + 24)) {
    68          x["when"] = A.load.Float64(ptr + 0);
    69        } else {
    70          delete x["when"];
    71        }
    72        if (A.load.Bool(ptr + 25)) {
    73          x["delayInMinutes"] = A.load.Float64(ptr + 8);
    74        } else {
    75          delete x["delayInMinutes"];
    76        }
    77        if (A.load.Bool(ptr + 26)) {
    78          x["periodInMinutes"] = A.load.Float64(ptr + 16);
    79        } else {
    80          delete x["periodInMinutes"];
    81        }
    82        return create === A.H.TRUE ? A.H.push(x) : ref;
    83      },
    84      "has_Clear": (): heap.Ref<boolean> => {
    85        if (WEBEXT?.alarms && "clear" in WEBEXT?.alarms) {
    86          return A.H.TRUE;
    87        }
    88        return A.H.FALSE;
    89      },
    90      "func_Clear": (fn: Pointer): void => {
    91        A.store.Ref(fn, WEBEXT.alarms.clear);
    92      },
    93      "call_Clear": (retPtr: Pointer, name: heap.Ref<object>): void => {
    94        const _ret = WEBEXT.alarms.clear(A.H.get<object>(name));
    95        A.store.Ref(retPtr, _ret);
    96      },
    97      "try_Clear": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
    98        try {
    99          const _ret = WEBEXT.alarms.clear(A.H.get<object>(name));
   100          A.store.Ref(retPtr, _ret);
   101          return A.H.TRUE;
   102        } catch (err: any) {
   103          A.store.Ref(errPtr, err);
   104          return A.H.FALSE;
   105        }
   106      },
   107      "has_ClearAll": (): heap.Ref<boolean> => {
   108        if (WEBEXT?.alarms && "clearAll" in WEBEXT?.alarms) {
   109          return A.H.TRUE;
   110        }
   111        return A.H.FALSE;
   112      },
   113      "func_ClearAll": (fn: Pointer): void => {
   114        A.store.Ref(fn, WEBEXT.alarms.clearAll);
   115      },
   116      "call_ClearAll": (retPtr: Pointer): void => {
   117        const _ret = WEBEXT.alarms.clearAll();
   118        A.store.Ref(retPtr, _ret);
   119      },
   120      "try_ClearAll": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   121        try {
   122          const _ret = WEBEXT.alarms.clearAll();
   123          A.store.Ref(retPtr, _ret);
   124          return A.H.TRUE;
   125        } catch (err: any) {
   126          A.store.Ref(errPtr, err);
   127          return A.H.FALSE;
   128        }
   129      },
   130      "has_Create": (): heap.Ref<boolean> => {
   131        if (WEBEXT?.alarms && "create" in WEBEXT?.alarms) {
   132          return A.H.TRUE;
   133        }
   134        return A.H.FALSE;
   135      },
   136      "func_Create": (fn: Pointer): void => {
   137        A.store.Ref(fn, WEBEXT.alarms.create);
   138      },
   139      "call_Create": (retPtr: Pointer, name: heap.Ref<object>, alarmInfo: Pointer): void => {
   140        const alarmInfo_ffi = {};
   141  
   142        if (A.load.Bool(alarmInfo + 24)) {
   143          alarmInfo_ffi["when"] = A.load.Float64(alarmInfo + 0);
   144        }
   145        if (A.load.Bool(alarmInfo + 25)) {
   146          alarmInfo_ffi["delayInMinutes"] = A.load.Float64(alarmInfo + 8);
   147        }
   148        if (A.load.Bool(alarmInfo + 26)) {
   149          alarmInfo_ffi["periodInMinutes"] = A.load.Float64(alarmInfo + 16);
   150        }
   151  
   152        const _ret = WEBEXT.alarms.create(A.H.get<object>(name), alarmInfo_ffi);
   153        A.store.Ref(retPtr, _ret);
   154      },
   155      "try_Create": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>, alarmInfo: Pointer): heap.Ref<boolean> => {
   156        try {
   157          const alarmInfo_ffi = {};
   158  
   159          if (A.load.Bool(alarmInfo + 24)) {
   160            alarmInfo_ffi["when"] = A.load.Float64(alarmInfo + 0);
   161          }
   162          if (A.load.Bool(alarmInfo + 25)) {
   163            alarmInfo_ffi["delayInMinutes"] = A.load.Float64(alarmInfo + 8);
   164          }
   165          if (A.load.Bool(alarmInfo + 26)) {
   166            alarmInfo_ffi["periodInMinutes"] = A.load.Float64(alarmInfo + 16);
   167          }
   168  
   169          const _ret = WEBEXT.alarms.create(A.H.get<object>(name), alarmInfo_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      "has_Get": (): heap.Ref<boolean> => {
   178        if (WEBEXT?.alarms && "get" in WEBEXT?.alarms) {
   179          return A.H.TRUE;
   180        }
   181        return A.H.FALSE;
   182      },
   183      "func_Get": (fn: Pointer): void => {
   184        A.store.Ref(fn, WEBEXT.alarms.get);
   185      },
   186      "call_Get": (retPtr: Pointer, name: heap.Ref<object>): void => {
   187        const _ret = WEBEXT.alarms.get(A.H.get<object>(name));
   188        A.store.Ref(retPtr, _ret);
   189      },
   190      "try_Get": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
   191        try {
   192          const _ret = WEBEXT.alarms.get(A.H.get<object>(name));
   193          A.store.Ref(retPtr, _ret);
   194          return A.H.TRUE;
   195        } catch (err: any) {
   196          A.store.Ref(errPtr, err);
   197          return A.H.FALSE;
   198        }
   199      },
   200      "has_GetAll": (): heap.Ref<boolean> => {
   201        if (WEBEXT?.alarms && "getAll" in WEBEXT?.alarms) {
   202          return A.H.TRUE;
   203        }
   204        return A.H.FALSE;
   205      },
   206      "func_GetAll": (fn: Pointer): void => {
   207        A.store.Ref(fn, WEBEXT.alarms.getAll);
   208      },
   209      "call_GetAll": (retPtr: Pointer): void => {
   210        const _ret = WEBEXT.alarms.getAll();
   211        A.store.Ref(retPtr, _ret);
   212      },
   213      "try_GetAll": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   214        try {
   215          const _ret = WEBEXT.alarms.getAll();
   216          A.store.Ref(retPtr, _ret);
   217          return A.H.TRUE;
   218        } catch (err: any) {
   219          A.store.Ref(errPtr, err);
   220          return A.H.FALSE;
   221        }
   222      },
   223      "has_OnAlarm": (): heap.Ref<boolean> => {
   224        if (WEBEXT?.alarms?.onAlarm && "addListener" in WEBEXT?.alarms?.onAlarm) {
   225          return A.H.TRUE;
   226        }
   227        return A.H.FALSE;
   228      },
   229      "func_OnAlarm": (fn: Pointer): void => {
   230        A.store.Ref(fn, WEBEXT.alarms.onAlarm.addListener);
   231      },
   232      "call_OnAlarm": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   233        const _ret = WEBEXT.alarms.onAlarm.addListener(A.H.get<object>(callback));
   234      },
   235      "try_OnAlarm": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   236        try {
   237          const _ret = WEBEXT.alarms.onAlarm.addListener(A.H.get<object>(callback));
   238          return A.H.TRUE;
   239        } catch (err: any) {
   240          A.store.Ref(errPtr, err);
   241          return A.H.FALSE;
   242        }
   243      },
   244      "has_OffAlarm": (): heap.Ref<boolean> => {
   245        if (WEBEXT?.alarms?.onAlarm && "removeListener" in WEBEXT?.alarms?.onAlarm) {
   246          return A.H.TRUE;
   247        }
   248        return A.H.FALSE;
   249      },
   250      "func_OffAlarm": (fn: Pointer): void => {
   251        A.store.Ref(fn, WEBEXT.alarms.onAlarm.removeListener);
   252      },
   253      "call_OffAlarm": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   254        const _ret = WEBEXT.alarms.onAlarm.removeListener(A.H.get<object>(callback));
   255      },
   256      "try_OffAlarm": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   257        try {
   258          const _ret = WEBEXT.alarms.onAlarm.removeListener(A.H.get<object>(callback));
   259          return A.H.TRUE;
   260        } catch (err: any) {
   261          A.store.Ref(errPtr, err);
   262          return A.H.FALSE;
   263        }
   264      },
   265      "has_HasOnAlarm": (): heap.Ref<boolean> => {
   266        if (WEBEXT?.alarms?.onAlarm && "hasListener" in WEBEXT?.alarms?.onAlarm) {
   267          return A.H.TRUE;
   268        }
   269        return A.H.FALSE;
   270      },
   271      "func_HasOnAlarm": (fn: Pointer): void => {
   272        A.store.Ref(fn, WEBEXT.alarms.onAlarm.hasListener);
   273      },
   274      "call_HasOnAlarm": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   275        const _ret = WEBEXT.alarms.onAlarm.hasListener(A.H.get<object>(callback));
   276        A.store.Bool(retPtr, _ret);
   277      },
   278      "try_HasOnAlarm": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   279        try {
   280          const _ret = WEBEXT.alarms.onAlarm.hasListener(A.H.get<object>(callback));
   281          A.store.Bool(retPtr, _ret);
   282          return A.H.TRUE;
   283        } catch (err: any) {
   284          A.store.Ref(errPtr, err);
   285          return A.H.FALSE;
   286        }
   287      },
   288    };
   289  });