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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/gcm", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "get_MAX_MESSAGE_SIZE": (retPtr: Pointer): heap.Ref<boolean> => {
     8        if (WEBEXT?.gcm && "MAX_MESSAGE_SIZE" in WEBEXT?.gcm) {
     9          const val = WEBEXT.gcm.MAX_MESSAGE_SIZE;
    10          A.store.Ref(retPtr, val);
    11          return A.H.TRUE;
    12        }
    13  
    14        return A.H.FALSE;
    15      },
    16      "set_MAX_MESSAGE_SIZE": (val: heap.Ref<object>): heap.Ref<boolean> => {
    17        return Reflect.set(WEBEXT.gcm, "MAX_MESSAGE_SIZE", A.H.get<object>(val), WEBEXT.gcm) ? A.H.TRUE : A.H.FALSE;
    18      },
    19  
    20      "store_OnMessageArgMessage": (ptr: Pointer, ref: heap.Ref<any>) => {
    21        const x = A.H.get<any>(ref);
    22  
    23        if (typeof x === "undefined") {
    24          A.store.Bool(ptr + 12, false);
    25          A.store.Ref(ptr + 0, undefined);
    26          A.store.Ref(ptr + 4, undefined);
    27          A.store.Ref(ptr + 8, undefined);
    28        } else {
    29          A.store.Bool(ptr + 12, true);
    30          A.store.Ref(ptr + 0, x["collapseKey"]);
    31          A.store.Ref(ptr + 4, x["data"]);
    32          A.store.Ref(ptr + 8, x["from"]);
    33        }
    34      },
    35      "load_OnMessageArgMessage": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    36        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    37  
    38        x["collapseKey"] = A.load.Ref(ptr + 0, undefined);
    39        x["data"] = A.load.Ref(ptr + 4, undefined);
    40        x["from"] = A.load.Ref(ptr + 8, undefined);
    41        return create === A.H.TRUE ? A.H.push(x) : ref;
    42      },
    43  
    44      "store_OnSendErrorArgError": (ptr: Pointer, ref: heap.Ref<any>) => {
    45        const x = A.H.get<any>(ref);
    46  
    47        if (typeof x === "undefined") {
    48          A.store.Bool(ptr + 12, false);
    49          A.store.Ref(ptr + 0, undefined);
    50          A.store.Ref(ptr + 4, undefined);
    51          A.store.Ref(ptr + 8, undefined);
    52        } else {
    53          A.store.Bool(ptr + 12, true);
    54          A.store.Ref(ptr + 0, x["details"]);
    55          A.store.Ref(ptr + 4, x["errorMessage"]);
    56          A.store.Ref(ptr + 8, x["messageId"]);
    57        }
    58      },
    59      "load_OnSendErrorArgError": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    60        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    61  
    62        x["details"] = A.load.Ref(ptr + 0, undefined);
    63        x["errorMessage"] = A.load.Ref(ptr + 4, undefined);
    64        x["messageId"] = A.load.Ref(ptr + 8, undefined);
    65        return create === A.H.TRUE ? A.H.push(x) : ref;
    66      },
    67  
    68      "store_SendArgMessage": (ptr: Pointer, ref: heap.Ref<any>) => {
    69        const x = A.H.get<any>(ref);
    70  
    71        if (typeof x === "undefined") {
    72          A.store.Bool(ptr + 25, false);
    73          A.store.Ref(ptr + 0, undefined);
    74          A.store.Ref(ptr + 4, undefined);
    75          A.store.Ref(ptr + 8, undefined);
    76          A.store.Bool(ptr + 24, false);
    77          A.store.Int64(ptr + 16, 0);
    78        } else {
    79          A.store.Bool(ptr + 25, true);
    80          A.store.Ref(ptr + 0, x["data"]);
    81          A.store.Ref(ptr + 4, x["destinationId"]);
    82          A.store.Ref(ptr + 8, x["messageId"]);
    83          A.store.Bool(ptr + 24, "timeToLive" in x ? true : false);
    84          A.store.Int64(ptr + 16, x["timeToLive"] === undefined ? 0 : (x["timeToLive"] as number));
    85        }
    86      },
    87      "load_SendArgMessage": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    88        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    89  
    90        x["data"] = A.load.Ref(ptr + 0, undefined);
    91        x["destinationId"] = A.load.Ref(ptr + 4, undefined);
    92        x["messageId"] = A.load.Ref(ptr + 8, undefined);
    93        if (A.load.Bool(ptr + 24)) {
    94          x["timeToLive"] = A.load.Int64(ptr + 16);
    95        } else {
    96          delete x["timeToLive"];
    97        }
    98        return create === A.H.TRUE ? A.H.push(x) : ref;
    99      },
   100      "has_OnMessage": (): heap.Ref<boolean> => {
   101        if (WEBEXT?.gcm?.onMessage && "addListener" in WEBEXT?.gcm?.onMessage) {
   102          return A.H.TRUE;
   103        }
   104        return A.H.FALSE;
   105      },
   106      "func_OnMessage": (fn: Pointer): void => {
   107        A.store.Ref(fn, WEBEXT.gcm.onMessage.addListener);
   108      },
   109      "call_OnMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   110        const _ret = WEBEXT.gcm.onMessage.addListener(A.H.get<object>(callback));
   111      },
   112      "try_OnMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   113        try {
   114          const _ret = WEBEXT.gcm.onMessage.addListener(A.H.get<object>(callback));
   115          return A.H.TRUE;
   116        } catch (err: any) {
   117          A.store.Ref(errPtr, err);
   118          return A.H.FALSE;
   119        }
   120      },
   121      "has_OffMessage": (): heap.Ref<boolean> => {
   122        if (WEBEXT?.gcm?.onMessage && "removeListener" in WEBEXT?.gcm?.onMessage) {
   123          return A.H.TRUE;
   124        }
   125        return A.H.FALSE;
   126      },
   127      "func_OffMessage": (fn: Pointer): void => {
   128        A.store.Ref(fn, WEBEXT.gcm.onMessage.removeListener);
   129      },
   130      "call_OffMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   131        const _ret = WEBEXT.gcm.onMessage.removeListener(A.H.get<object>(callback));
   132      },
   133      "try_OffMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   134        try {
   135          const _ret = WEBEXT.gcm.onMessage.removeListener(A.H.get<object>(callback));
   136          return A.H.TRUE;
   137        } catch (err: any) {
   138          A.store.Ref(errPtr, err);
   139          return A.H.FALSE;
   140        }
   141      },
   142      "has_HasOnMessage": (): heap.Ref<boolean> => {
   143        if (WEBEXT?.gcm?.onMessage && "hasListener" in WEBEXT?.gcm?.onMessage) {
   144          return A.H.TRUE;
   145        }
   146        return A.H.FALSE;
   147      },
   148      "func_HasOnMessage": (fn: Pointer): void => {
   149        A.store.Ref(fn, WEBEXT.gcm.onMessage.hasListener);
   150      },
   151      "call_HasOnMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   152        const _ret = WEBEXT.gcm.onMessage.hasListener(A.H.get<object>(callback));
   153        A.store.Bool(retPtr, _ret);
   154      },
   155      "try_HasOnMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   156        try {
   157          const _ret = WEBEXT.gcm.onMessage.hasListener(A.H.get<object>(callback));
   158          A.store.Bool(retPtr, _ret);
   159          return A.H.TRUE;
   160        } catch (err: any) {
   161          A.store.Ref(errPtr, err);
   162          return A.H.FALSE;
   163        }
   164      },
   165      "has_OnMessagesDeleted": (): heap.Ref<boolean> => {
   166        if (WEBEXT?.gcm?.onMessagesDeleted && "addListener" in WEBEXT?.gcm?.onMessagesDeleted) {
   167          return A.H.TRUE;
   168        }
   169        return A.H.FALSE;
   170      },
   171      "func_OnMessagesDeleted": (fn: Pointer): void => {
   172        A.store.Ref(fn, WEBEXT.gcm.onMessagesDeleted.addListener);
   173      },
   174      "call_OnMessagesDeleted": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   175        const _ret = WEBEXT.gcm.onMessagesDeleted.addListener(A.H.get<object>(callback));
   176      },
   177      "try_OnMessagesDeleted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   178        try {
   179          const _ret = WEBEXT.gcm.onMessagesDeleted.addListener(A.H.get<object>(callback));
   180          return A.H.TRUE;
   181        } catch (err: any) {
   182          A.store.Ref(errPtr, err);
   183          return A.H.FALSE;
   184        }
   185      },
   186      "has_OffMessagesDeleted": (): heap.Ref<boolean> => {
   187        if (WEBEXT?.gcm?.onMessagesDeleted && "removeListener" in WEBEXT?.gcm?.onMessagesDeleted) {
   188          return A.H.TRUE;
   189        }
   190        return A.H.FALSE;
   191      },
   192      "func_OffMessagesDeleted": (fn: Pointer): void => {
   193        A.store.Ref(fn, WEBEXT.gcm.onMessagesDeleted.removeListener);
   194      },
   195      "call_OffMessagesDeleted": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   196        const _ret = WEBEXT.gcm.onMessagesDeleted.removeListener(A.H.get<object>(callback));
   197      },
   198      "try_OffMessagesDeleted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   199        try {
   200          const _ret = WEBEXT.gcm.onMessagesDeleted.removeListener(A.H.get<object>(callback));
   201          return A.H.TRUE;
   202        } catch (err: any) {
   203          A.store.Ref(errPtr, err);
   204          return A.H.FALSE;
   205        }
   206      },
   207      "has_HasOnMessagesDeleted": (): heap.Ref<boolean> => {
   208        if (WEBEXT?.gcm?.onMessagesDeleted && "hasListener" in WEBEXT?.gcm?.onMessagesDeleted) {
   209          return A.H.TRUE;
   210        }
   211        return A.H.FALSE;
   212      },
   213      "func_HasOnMessagesDeleted": (fn: Pointer): void => {
   214        A.store.Ref(fn, WEBEXT.gcm.onMessagesDeleted.hasListener);
   215      },
   216      "call_HasOnMessagesDeleted": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   217        const _ret = WEBEXT.gcm.onMessagesDeleted.hasListener(A.H.get<object>(callback));
   218        A.store.Bool(retPtr, _ret);
   219      },
   220      "try_HasOnMessagesDeleted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   221        try {
   222          const _ret = WEBEXT.gcm.onMessagesDeleted.hasListener(A.H.get<object>(callback));
   223          A.store.Bool(retPtr, _ret);
   224          return A.H.TRUE;
   225        } catch (err: any) {
   226          A.store.Ref(errPtr, err);
   227          return A.H.FALSE;
   228        }
   229      },
   230      "has_OnSendError": (): heap.Ref<boolean> => {
   231        if (WEBEXT?.gcm?.onSendError && "addListener" in WEBEXT?.gcm?.onSendError) {
   232          return A.H.TRUE;
   233        }
   234        return A.H.FALSE;
   235      },
   236      "func_OnSendError": (fn: Pointer): void => {
   237        A.store.Ref(fn, WEBEXT.gcm.onSendError.addListener);
   238      },
   239      "call_OnSendError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   240        const _ret = WEBEXT.gcm.onSendError.addListener(A.H.get<object>(callback));
   241      },
   242      "try_OnSendError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   243        try {
   244          const _ret = WEBEXT.gcm.onSendError.addListener(A.H.get<object>(callback));
   245          return A.H.TRUE;
   246        } catch (err: any) {
   247          A.store.Ref(errPtr, err);
   248          return A.H.FALSE;
   249        }
   250      },
   251      "has_OffSendError": (): heap.Ref<boolean> => {
   252        if (WEBEXT?.gcm?.onSendError && "removeListener" in WEBEXT?.gcm?.onSendError) {
   253          return A.H.TRUE;
   254        }
   255        return A.H.FALSE;
   256      },
   257      "func_OffSendError": (fn: Pointer): void => {
   258        A.store.Ref(fn, WEBEXT.gcm.onSendError.removeListener);
   259      },
   260      "call_OffSendError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   261        const _ret = WEBEXT.gcm.onSendError.removeListener(A.H.get<object>(callback));
   262      },
   263      "try_OffSendError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   264        try {
   265          const _ret = WEBEXT.gcm.onSendError.removeListener(A.H.get<object>(callback));
   266          return A.H.TRUE;
   267        } catch (err: any) {
   268          A.store.Ref(errPtr, err);
   269          return A.H.FALSE;
   270        }
   271      },
   272      "has_HasOnSendError": (): heap.Ref<boolean> => {
   273        if (WEBEXT?.gcm?.onSendError && "hasListener" in WEBEXT?.gcm?.onSendError) {
   274          return A.H.TRUE;
   275        }
   276        return A.H.FALSE;
   277      },
   278      "func_HasOnSendError": (fn: Pointer): void => {
   279        A.store.Ref(fn, WEBEXT.gcm.onSendError.hasListener);
   280      },
   281      "call_HasOnSendError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   282        const _ret = WEBEXT.gcm.onSendError.hasListener(A.H.get<object>(callback));
   283        A.store.Bool(retPtr, _ret);
   284      },
   285      "try_HasOnSendError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   286        try {
   287          const _ret = WEBEXT.gcm.onSendError.hasListener(A.H.get<object>(callback));
   288          A.store.Bool(retPtr, _ret);
   289          return A.H.TRUE;
   290        } catch (err: any) {
   291          A.store.Ref(errPtr, err);
   292          return A.H.FALSE;
   293        }
   294      },
   295      "has_Register": (): heap.Ref<boolean> => {
   296        if (WEBEXT?.gcm && "register" in WEBEXT?.gcm) {
   297          return A.H.TRUE;
   298        }
   299        return A.H.FALSE;
   300      },
   301      "func_Register": (fn: Pointer): void => {
   302        A.store.Ref(fn, WEBEXT.gcm.register);
   303      },
   304      "call_Register": (retPtr: Pointer, senderIds: heap.Ref<object>): void => {
   305        const _ret = WEBEXT.gcm.register(A.H.get<object>(senderIds));
   306        A.store.Ref(retPtr, _ret);
   307      },
   308      "try_Register": (retPtr: Pointer, errPtr: Pointer, senderIds: heap.Ref<object>): heap.Ref<boolean> => {
   309        try {
   310          const _ret = WEBEXT.gcm.register(A.H.get<object>(senderIds));
   311          A.store.Ref(retPtr, _ret);
   312          return A.H.TRUE;
   313        } catch (err: any) {
   314          A.store.Ref(errPtr, err);
   315          return A.H.FALSE;
   316        }
   317      },
   318      "has_Send": (): heap.Ref<boolean> => {
   319        if (WEBEXT?.gcm && "send" in WEBEXT?.gcm) {
   320          return A.H.TRUE;
   321        }
   322        return A.H.FALSE;
   323      },
   324      "func_Send": (fn: Pointer): void => {
   325        A.store.Ref(fn, WEBEXT.gcm.send);
   326      },
   327      "call_Send": (retPtr: Pointer, message: Pointer): void => {
   328        const message_ffi = {};
   329  
   330        message_ffi["data"] = A.load.Ref(message + 0, undefined);
   331        message_ffi["destinationId"] = A.load.Ref(message + 4, undefined);
   332        message_ffi["messageId"] = A.load.Ref(message + 8, undefined);
   333        if (A.load.Bool(message + 24)) {
   334          message_ffi["timeToLive"] = A.load.Int64(message + 16);
   335        }
   336  
   337        const _ret = WEBEXT.gcm.send(message_ffi);
   338        A.store.Ref(retPtr, _ret);
   339      },
   340      "try_Send": (retPtr: Pointer, errPtr: Pointer, message: Pointer): heap.Ref<boolean> => {
   341        try {
   342          const message_ffi = {};
   343  
   344          message_ffi["data"] = A.load.Ref(message + 0, undefined);
   345          message_ffi["destinationId"] = A.load.Ref(message + 4, undefined);
   346          message_ffi["messageId"] = A.load.Ref(message + 8, undefined);
   347          if (A.load.Bool(message + 24)) {
   348            message_ffi["timeToLive"] = A.load.Int64(message + 16);
   349          }
   350  
   351          const _ret = WEBEXT.gcm.send(message_ffi);
   352          A.store.Ref(retPtr, _ret);
   353          return A.H.TRUE;
   354        } catch (err: any) {
   355          A.store.Ref(errPtr, err);
   356          return A.H.FALSE;
   357        }
   358      },
   359      "has_Unregister": (): heap.Ref<boolean> => {
   360        if (WEBEXT?.gcm && "unregister" in WEBEXT?.gcm) {
   361          return A.H.TRUE;
   362        }
   363        return A.H.FALSE;
   364      },
   365      "func_Unregister": (fn: Pointer): void => {
   366        A.store.Ref(fn, WEBEXT.gcm.unregister);
   367      },
   368      "call_Unregister": (retPtr: Pointer): void => {
   369        const _ret = WEBEXT.gcm.unregister();
   370        A.store.Ref(retPtr, _ret);
   371      },
   372      "try_Unregister": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   373        try {
   374          const _ret = WEBEXT.gcm.unregister();
   375          A.store.Ref(retPtr, _ret);
   376          return A.H.TRUE;
   377        } catch (err: any) {
   378          A.store.Ref(errPtr, err);
   379          return A.H.FALSE;
   380        }
   381      },
   382    };
   383  });