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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/mimehandlerprivate", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_StreamInfo": (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 + 23, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14          A.store.Ref(ptr + 8, undefined);
    15          A.store.Bool(ptr + 21, false);
    16          A.store.Int32(ptr + 12, 0);
    17          A.store.Ref(ptr + 16, undefined);
    18          A.store.Bool(ptr + 22, false);
    19          A.store.Bool(ptr + 20, false);
    20        } else {
    21          A.store.Bool(ptr + 23, true);
    22          A.store.Ref(ptr + 0, x["mimeType"]);
    23          A.store.Ref(ptr + 4, x["originalUrl"]);
    24          A.store.Ref(ptr + 8, x["streamUrl"]);
    25          A.store.Bool(ptr + 21, "tabId" in x ? true : false);
    26          A.store.Int32(ptr + 12, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    27          A.store.Ref(ptr + 16, x["responseHeaders"]);
    28          A.store.Bool(ptr + 22, "embedded" in x ? true : false);
    29          A.store.Bool(ptr + 20, x["embedded"] ? true : false);
    30        }
    31      },
    32      "load_StreamInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    33        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    34  
    35        x["mimeType"] = A.load.Ref(ptr + 0, undefined);
    36        x["originalUrl"] = A.load.Ref(ptr + 4, undefined);
    37        x["streamUrl"] = A.load.Ref(ptr + 8, undefined);
    38        if (A.load.Bool(ptr + 21)) {
    39          x["tabId"] = A.load.Int32(ptr + 12);
    40        } else {
    41          delete x["tabId"];
    42        }
    43        x["responseHeaders"] = A.load.Ref(ptr + 16, undefined);
    44        if (A.load.Bool(ptr + 22)) {
    45          x["embedded"] = A.load.Bool(ptr + 20);
    46        } else {
    47          delete x["embedded"];
    48        }
    49        return create === A.H.TRUE ? A.H.push(x) : ref;
    50      },
    51  
    52      "store_PdfPluginAttributes": (ptr: Pointer, ref: heap.Ref<any>) => {
    53        const x = A.H.get<any>(ref);
    54  
    55        if (typeof x === "undefined") {
    56          A.store.Bool(ptr + 11, false);
    57          A.store.Bool(ptr + 9, false);
    58          A.store.Float64(ptr + 0, 0);
    59          A.store.Bool(ptr + 10, false);
    60          A.store.Bool(ptr + 8, false);
    61        } else {
    62          A.store.Bool(ptr + 11, true);
    63          A.store.Bool(ptr + 9, "backgroundColor" in x ? true : false);
    64          A.store.Float64(ptr + 0, x["backgroundColor"] === undefined ? 0 : (x["backgroundColor"] as number));
    65          A.store.Bool(ptr + 10, "allowJavascript" in x ? true : false);
    66          A.store.Bool(ptr + 8, x["allowJavascript"] ? true : false);
    67        }
    68      },
    69      "load_PdfPluginAttributes": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    70        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    71  
    72        if (A.load.Bool(ptr + 9)) {
    73          x["backgroundColor"] = A.load.Float64(ptr + 0);
    74        } else {
    75          delete x["backgroundColor"];
    76        }
    77        if (A.load.Bool(ptr + 10)) {
    78          x["allowJavascript"] = A.load.Bool(ptr + 8);
    79        } else {
    80          delete x["allowJavascript"];
    81        }
    82        return create === A.H.TRUE ? A.H.push(x) : ref;
    83      },
    84      "has_GetStreamInfo": (): heap.Ref<boolean> => {
    85        if (WEBEXT?.mimeHandlerPrivate && "getStreamInfo" in WEBEXT?.mimeHandlerPrivate) {
    86          return A.H.TRUE;
    87        }
    88        return A.H.FALSE;
    89      },
    90      "func_GetStreamInfo": (fn: Pointer): void => {
    91        A.store.Ref(fn, WEBEXT.mimeHandlerPrivate.getStreamInfo);
    92      },
    93      "call_GetStreamInfo": (retPtr: Pointer, callback: heap.Ref<object>): void => {
    94        const _ret = WEBEXT.mimeHandlerPrivate.getStreamInfo(A.H.get<object>(callback));
    95      },
    96      "try_GetStreamInfo": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
    97        try {
    98          const _ret = WEBEXT.mimeHandlerPrivate.getStreamInfo(A.H.get<object>(callback));
    99          return A.H.TRUE;
   100        } catch (err: any) {
   101          A.store.Ref(errPtr, err);
   102          return A.H.FALSE;
   103        }
   104      },
   105      "has_OnSave": (): heap.Ref<boolean> => {
   106        if (WEBEXT?.mimeHandlerPrivate?.onSave && "addListener" in WEBEXT?.mimeHandlerPrivate?.onSave) {
   107          return A.H.TRUE;
   108        }
   109        return A.H.FALSE;
   110      },
   111      "func_OnSave": (fn: Pointer): void => {
   112        A.store.Ref(fn, WEBEXT.mimeHandlerPrivate.onSave.addListener);
   113      },
   114      "call_OnSave": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   115        const _ret = WEBEXT.mimeHandlerPrivate.onSave.addListener(A.H.get<object>(callback));
   116      },
   117      "try_OnSave": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   118        try {
   119          const _ret = WEBEXT.mimeHandlerPrivate.onSave.addListener(A.H.get<object>(callback));
   120          return A.H.TRUE;
   121        } catch (err: any) {
   122          A.store.Ref(errPtr, err);
   123          return A.H.FALSE;
   124        }
   125      },
   126      "has_OffSave": (): heap.Ref<boolean> => {
   127        if (WEBEXT?.mimeHandlerPrivate?.onSave && "removeListener" in WEBEXT?.mimeHandlerPrivate?.onSave) {
   128          return A.H.TRUE;
   129        }
   130        return A.H.FALSE;
   131      },
   132      "func_OffSave": (fn: Pointer): void => {
   133        A.store.Ref(fn, WEBEXT.mimeHandlerPrivate.onSave.removeListener);
   134      },
   135      "call_OffSave": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   136        const _ret = WEBEXT.mimeHandlerPrivate.onSave.removeListener(A.H.get<object>(callback));
   137      },
   138      "try_OffSave": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   139        try {
   140          const _ret = WEBEXT.mimeHandlerPrivate.onSave.removeListener(A.H.get<object>(callback));
   141          return A.H.TRUE;
   142        } catch (err: any) {
   143          A.store.Ref(errPtr, err);
   144          return A.H.FALSE;
   145        }
   146      },
   147      "has_HasOnSave": (): heap.Ref<boolean> => {
   148        if (WEBEXT?.mimeHandlerPrivate?.onSave && "hasListener" in WEBEXT?.mimeHandlerPrivate?.onSave) {
   149          return A.H.TRUE;
   150        }
   151        return A.H.FALSE;
   152      },
   153      "func_HasOnSave": (fn: Pointer): void => {
   154        A.store.Ref(fn, WEBEXT.mimeHandlerPrivate.onSave.hasListener);
   155      },
   156      "call_HasOnSave": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   157        const _ret = WEBEXT.mimeHandlerPrivate.onSave.hasListener(A.H.get<object>(callback));
   158        A.store.Bool(retPtr, _ret);
   159      },
   160      "try_HasOnSave": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   161        try {
   162          const _ret = WEBEXT.mimeHandlerPrivate.onSave.hasListener(A.H.get<object>(callback));
   163          A.store.Bool(retPtr, _ret);
   164          return A.H.TRUE;
   165        } catch (err: any) {
   166          A.store.Ref(errPtr, err);
   167          return A.H.FALSE;
   168        }
   169      },
   170      "has_SetPdfPluginAttributes": (): heap.Ref<boolean> => {
   171        if (WEBEXT?.mimeHandlerPrivate && "setPdfPluginAttributes" in WEBEXT?.mimeHandlerPrivate) {
   172          return A.H.TRUE;
   173        }
   174        return A.H.FALSE;
   175      },
   176      "func_SetPdfPluginAttributes": (fn: Pointer): void => {
   177        A.store.Ref(fn, WEBEXT.mimeHandlerPrivate.setPdfPluginAttributes);
   178      },
   179      "call_SetPdfPluginAttributes": (retPtr: Pointer, pdfPluginAttributes: Pointer): void => {
   180        const pdfPluginAttributes_ffi = {};
   181  
   182        if (A.load.Bool(pdfPluginAttributes + 9)) {
   183          pdfPluginAttributes_ffi["backgroundColor"] = A.load.Float64(pdfPluginAttributes + 0);
   184        }
   185        if (A.load.Bool(pdfPluginAttributes + 10)) {
   186          pdfPluginAttributes_ffi["allowJavascript"] = A.load.Bool(pdfPluginAttributes + 8);
   187        }
   188  
   189        const _ret = WEBEXT.mimeHandlerPrivate.setPdfPluginAttributes(pdfPluginAttributes_ffi);
   190      },
   191      "try_SetPdfPluginAttributes": (
   192        retPtr: Pointer,
   193        errPtr: Pointer,
   194        pdfPluginAttributes: Pointer
   195      ): heap.Ref<boolean> => {
   196        try {
   197          const pdfPluginAttributes_ffi = {};
   198  
   199          if (A.load.Bool(pdfPluginAttributes + 9)) {
   200            pdfPluginAttributes_ffi["backgroundColor"] = A.load.Float64(pdfPluginAttributes + 0);
   201          }
   202          if (A.load.Bool(pdfPluginAttributes + 10)) {
   203            pdfPluginAttributes_ffi["allowJavascript"] = A.load.Bool(pdfPluginAttributes + 8);
   204          }
   205  
   206          const _ret = WEBEXT.mimeHandlerPrivate.setPdfPluginAttributes(pdfPluginAttributes_ffi);
   207          return A.H.TRUE;
   208        } catch (err: any) {
   209          A.store.Ref(errPtr, err);
   210          return A.H.FALSE;
   211        }
   212      },
   213      "has_SetShowBeforeUnloadDialog": (): heap.Ref<boolean> => {
   214        if (WEBEXT?.mimeHandlerPrivate && "setShowBeforeUnloadDialog" in WEBEXT?.mimeHandlerPrivate) {
   215          return A.H.TRUE;
   216        }
   217        return A.H.FALSE;
   218      },
   219      "func_SetShowBeforeUnloadDialog": (fn: Pointer): void => {
   220        A.store.Ref(fn, WEBEXT.mimeHandlerPrivate.setShowBeforeUnloadDialog);
   221      },
   222      "call_SetShowBeforeUnloadDialog": (
   223        retPtr: Pointer,
   224        showDialog: heap.Ref<boolean>,
   225        callback: heap.Ref<object>
   226      ): void => {
   227        const _ret = WEBEXT.mimeHandlerPrivate.setShowBeforeUnloadDialog(
   228          showDialog === A.H.TRUE,
   229          A.H.get<object>(callback)
   230        );
   231      },
   232      "try_SetShowBeforeUnloadDialog": (
   233        retPtr: Pointer,
   234        errPtr: Pointer,
   235        showDialog: heap.Ref<boolean>,
   236        callback: heap.Ref<object>
   237      ): heap.Ref<boolean> => {
   238        try {
   239          const _ret = WEBEXT.mimeHandlerPrivate.setShowBeforeUnloadDialog(
   240            showDialog === A.H.TRUE,
   241            A.H.get<object>(callback)
   242          );
   243          return A.H.TRUE;
   244        } catch (err: any) {
   245          A.store.Ref(errPtr, err);
   246          return A.H.FALSE;
   247        }
   248      },
   249    };
   250  });