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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/filesystem", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_AcceptOption": (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 + 12, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14          A.store.Ref(ptr + 8, undefined);
    15        } else {
    16          A.store.Bool(ptr + 12, true);
    17          A.store.Ref(ptr + 0, x["description"]);
    18          A.store.Ref(ptr + 4, x["mimeTypes"]);
    19          A.store.Ref(ptr + 8, x["extensions"]);
    20        }
    21      },
    22      "load_AcceptOption": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    23        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    24  
    25        x["description"] = A.load.Ref(ptr + 0, undefined);
    26        x["mimeTypes"] = A.load.Ref(ptr + 4, undefined);
    27        x["extensions"] = A.load.Ref(ptr + 8, undefined);
    28        return create === A.H.TRUE ? A.H.push(x) : ref;
    29      },
    30      "constof_ChooseEntryType": (ref: heap.Ref<string>): number => {
    31        const idx = ["openFile", "openWritableFile", "saveFile", "openDirectory"].indexOf(A.H.get(ref));
    32        return idx < 0 ? 0 : idx + 1;
    33      },
    34  
    35      "store_ChooseEntryOptions": (ptr: Pointer, ref: heap.Ref<any>) => {
    36        const x = A.H.get<any>(ref);
    37  
    38        if (typeof x === "undefined") {
    39          A.store.Bool(ptr + 16, false);
    40          A.store.Enum(ptr + 0, -1);
    41          A.store.Ref(ptr + 4, undefined);
    42          A.store.Ref(ptr + 8, undefined);
    43          A.store.Bool(ptr + 14, false);
    44          A.store.Bool(ptr + 12, false);
    45          A.store.Bool(ptr + 15, false);
    46          A.store.Bool(ptr + 13, false);
    47        } else {
    48          A.store.Bool(ptr + 16, true);
    49          A.store.Enum(
    50            ptr + 0,
    51            ["openFile", "openWritableFile", "saveFile", "openDirectory"].indexOf(x["type"] as string)
    52          );
    53          A.store.Ref(ptr + 4, x["suggestedName"]);
    54          A.store.Ref(ptr + 8, x["accepts"]);
    55          A.store.Bool(ptr + 14, "acceptsAllTypes" in x ? true : false);
    56          A.store.Bool(ptr + 12, x["acceptsAllTypes"] ? true : false);
    57          A.store.Bool(ptr + 15, "acceptsMultiple" in x ? true : false);
    58          A.store.Bool(ptr + 13, x["acceptsMultiple"] ? true : false);
    59        }
    60      },
    61      "load_ChooseEntryOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    62        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    63  
    64        x["type"] = A.load.Enum(ptr + 0, ["openFile", "openWritableFile", "saveFile", "openDirectory"]);
    65        x["suggestedName"] = A.load.Ref(ptr + 4, undefined);
    66        x["accepts"] = A.load.Ref(ptr + 8, undefined);
    67        if (A.load.Bool(ptr + 14)) {
    68          x["acceptsAllTypes"] = A.load.Bool(ptr + 12);
    69        } else {
    70          delete x["acceptsAllTypes"];
    71        }
    72        if (A.load.Bool(ptr + 15)) {
    73          x["acceptsMultiple"] = A.load.Bool(ptr + 13);
    74        } else {
    75          delete x["acceptsMultiple"];
    76        }
    77        return create === A.H.TRUE ? A.H.push(x) : ref;
    78      },
    79  
    80      "store_Volume": (ptr: Pointer, ref: heap.Ref<any>) => {
    81        const x = A.H.get<any>(ref);
    82  
    83        if (typeof x === "undefined") {
    84          A.store.Bool(ptr + 6, false);
    85          A.store.Ref(ptr + 0, undefined);
    86          A.store.Bool(ptr + 5, false);
    87          A.store.Bool(ptr + 4, false);
    88        } else {
    89          A.store.Bool(ptr + 6, true);
    90          A.store.Ref(ptr + 0, x["volumeId"]);
    91          A.store.Bool(ptr + 5, "writable" in x ? true : false);
    92          A.store.Bool(ptr + 4, x["writable"] ? true : false);
    93        }
    94      },
    95      "load_Volume": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    96        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    97  
    98        x["volumeId"] = A.load.Ref(ptr + 0, undefined);
    99        if (A.load.Bool(ptr + 5)) {
   100          x["writable"] = A.load.Bool(ptr + 4);
   101        } else {
   102          delete x["writable"];
   103        }
   104        return create === A.H.TRUE ? A.H.push(x) : ref;
   105      },
   106  
   107      "store_RequestFileSystemOptions": (ptr: Pointer, ref: heap.Ref<any>) => {
   108        const x = A.H.get<any>(ref);
   109  
   110        if (typeof x === "undefined") {
   111          A.store.Bool(ptr + 6, false);
   112          A.store.Ref(ptr + 0, undefined);
   113          A.store.Bool(ptr + 5, false);
   114          A.store.Bool(ptr + 4, false);
   115        } else {
   116          A.store.Bool(ptr + 6, true);
   117          A.store.Ref(ptr + 0, x["volumeId"]);
   118          A.store.Bool(ptr + 5, "writable" in x ? true : false);
   119          A.store.Bool(ptr + 4, x["writable"] ? true : false);
   120        }
   121      },
   122      "load_RequestFileSystemOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   123        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   124  
   125        x["volumeId"] = A.load.Ref(ptr + 0, undefined);
   126        if (A.load.Bool(ptr + 5)) {
   127          x["writable"] = A.load.Bool(ptr + 4);
   128        } else {
   129          delete x["writable"];
   130        }
   131        return create === A.H.TRUE ? A.H.push(x) : ref;
   132      },
   133  
   134      "store_VolumeListChangedEvent": (ptr: Pointer, ref: heap.Ref<any>) => {
   135        const x = A.H.get<any>(ref);
   136  
   137        if (typeof x === "undefined") {
   138          A.store.Bool(ptr + 4, false);
   139          A.store.Ref(ptr + 0, undefined);
   140        } else {
   141          A.store.Bool(ptr + 4, true);
   142          A.store.Ref(ptr + 0, x["volumes"]);
   143        }
   144      },
   145      "load_VolumeListChangedEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   146        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   147  
   148        x["volumes"] = A.load.Ref(ptr + 0, undefined);
   149        return create === A.H.TRUE ? A.H.push(x) : ref;
   150      },
   151      "has_ChooseEntry": (): heap.Ref<boolean> => {
   152        if (WEBEXT?.fileSystem && "chooseEntry" in WEBEXT?.fileSystem) {
   153          return A.H.TRUE;
   154        }
   155        return A.H.FALSE;
   156      },
   157      "func_ChooseEntry": (fn: Pointer): void => {
   158        A.store.Ref(fn, WEBEXT.fileSystem.chooseEntry);
   159      },
   160      "call_ChooseEntry": (retPtr: Pointer, options: Pointer, callback: heap.Ref<object>): void => {
   161        const options_ffi = {};
   162  
   163        options_ffi["type"] = A.load.Enum(options + 0, ["openFile", "openWritableFile", "saveFile", "openDirectory"]);
   164        options_ffi["suggestedName"] = A.load.Ref(options + 4, undefined);
   165        options_ffi["accepts"] = A.load.Ref(options + 8, undefined);
   166        if (A.load.Bool(options + 14)) {
   167          options_ffi["acceptsAllTypes"] = A.load.Bool(options + 12);
   168        }
   169        if (A.load.Bool(options + 15)) {
   170          options_ffi["acceptsMultiple"] = A.load.Bool(options + 13);
   171        }
   172  
   173        const _ret = WEBEXT.fileSystem.chooseEntry(options_ffi, A.H.get<object>(callback));
   174      },
   175      "try_ChooseEntry": (
   176        retPtr: Pointer,
   177        errPtr: Pointer,
   178        options: Pointer,
   179        callback: heap.Ref<object>
   180      ): heap.Ref<boolean> => {
   181        try {
   182          const options_ffi = {};
   183  
   184          options_ffi["type"] = A.load.Enum(options + 0, ["openFile", "openWritableFile", "saveFile", "openDirectory"]);
   185          options_ffi["suggestedName"] = A.load.Ref(options + 4, undefined);
   186          options_ffi["accepts"] = A.load.Ref(options + 8, undefined);
   187          if (A.load.Bool(options + 14)) {
   188            options_ffi["acceptsAllTypes"] = A.load.Bool(options + 12);
   189          }
   190          if (A.load.Bool(options + 15)) {
   191            options_ffi["acceptsMultiple"] = A.load.Bool(options + 13);
   192          }
   193  
   194          const _ret = WEBEXT.fileSystem.chooseEntry(options_ffi, A.H.get<object>(callback));
   195          return A.H.TRUE;
   196        } catch (err: any) {
   197          A.store.Ref(errPtr, err);
   198          return A.H.FALSE;
   199        }
   200      },
   201      "has_GetDisplayPath": (): heap.Ref<boolean> => {
   202        if (WEBEXT?.fileSystem && "getDisplayPath" in WEBEXT?.fileSystem) {
   203          return A.H.TRUE;
   204        }
   205        return A.H.FALSE;
   206      },
   207      "func_GetDisplayPath": (fn: Pointer): void => {
   208        A.store.Ref(fn, WEBEXT.fileSystem.getDisplayPath);
   209      },
   210      "call_GetDisplayPath": (retPtr: Pointer, entry: heap.Ref<object>): void => {
   211        const _ret = WEBEXT.fileSystem.getDisplayPath(A.H.get<object>(entry));
   212        A.store.Ref(retPtr, _ret);
   213      },
   214      "try_GetDisplayPath": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => {
   215        try {
   216          const _ret = WEBEXT.fileSystem.getDisplayPath(A.H.get<object>(entry));
   217          A.store.Ref(retPtr, _ret);
   218          return A.H.TRUE;
   219        } catch (err: any) {
   220          A.store.Ref(errPtr, err);
   221          return A.H.FALSE;
   222        }
   223      },
   224      "has_GetVolumeList": (): heap.Ref<boolean> => {
   225        if (WEBEXT?.fileSystem && "getVolumeList" in WEBEXT?.fileSystem) {
   226          return A.H.TRUE;
   227        }
   228        return A.H.FALSE;
   229      },
   230      "func_GetVolumeList": (fn: Pointer): void => {
   231        A.store.Ref(fn, WEBEXT.fileSystem.getVolumeList);
   232      },
   233      "call_GetVolumeList": (retPtr: Pointer): void => {
   234        const _ret = WEBEXT.fileSystem.getVolumeList();
   235        A.store.Ref(retPtr, _ret);
   236      },
   237      "try_GetVolumeList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   238        try {
   239          const _ret = WEBEXT.fileSystem.getVolumeList();
   240          A.store.Ref(retPtr, _ret);
   241          return A.H.TRUE;
   242        } catch (err: any) {
   243          A.store.Ref(errPtr, err);
   244          return A.H.FALSE;
   245        }
   246      },
   247      "has_GetWritableEntry": (): heap.Ref<boolean> => {
   248        if (WEBEXT?.fileSystem && "getWritableEntry" in WEBEXT?.fileSystem) {
   249          return A.H.TRUE;
   250        }
   251        return A.H.FALSE;
   252      },
   253      "func_GetWritableEntry": (fn: Pointer): void => {
   254        A.store.Ref(fn, WEBEXT.fileSystem.getWritableEntry);
   255      },
   256      "call_GetWritableEntry": (retPtr: Pointer, entry: heap.Ref<object>): void => {
   257        const _ret = WEBEXT.fileSystem.getWritableEntry(A.H.get<object>(entry));
   258        A.store.Ref(retPtr, _ret);
   259      },
   260      "try_GetWritableEntry": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => {
   261        try {
   262          const _ret = WEBEXT.fileSystem.getWritableEntry(A.H.get<object>(entry));
   263          A.store.Ref(retPtr, _ret);
   264          return A.H.TRUE;
   265        } catch (err: any) {
   266          A.store.Ref(errPtr, err);
   267          return A.H.FALSE;
   268        }
   269      },
   270      "has_IsRestorable": (): heap.Ref<boolean> => {
   271        if (WEBEXT?.fileSystem && "isRestorable" in WEBEXT?.fileSystem) {
   272          return A.H.TRUE;
   273        }
   274        return A.H.FALSE;
   275      },
   276      "func_IsRestorable": (fn: Pointer): void => {
   277        A.store.Ref(fn, WEBEXT.fileSystem.isRestorable);
   278      },
   279      "call_IsRestorable": (retPtr: Pointer, id: heap.Ref<object>): void => {
   280        const _ret = WEBEXT.fileSystem.isRestorable(A.H.get<object>(id));
   281        A.store.Ref(retPtr, _ret);
   282      },
   283      "try_IsRestorable": (retPtr: Pointer, errPtr: Pointer, id: heap.Ref<object>): heap.Ref<boolean> => {
   284        try {
   285          const _ret = WEBEXT.fileSystem.isRestorable(A.H.get<object>(id));
   286          A.store.Ref(retPtr, _ret);
   287          return A.H.TRUE;
   288        } catch (err: any) {
   289          A.store.Ref(errPtr, err);
   290          return A.H.FALSE;
   291        }
   292      },
   293      "has_IsWritableEntry": (): heap.Ref<boolean> => {
   294        if (WEBEXT?.fileSystem && "isWritableEntry" in WEBEXT?.fileSystem) {
   295          return A.H.TRUE;
   296        }
   297        return A.H.FALSE;
   298      },
   299      "func_IsWritableEntry": (fn: Pointer): void => {
   300        A.store.Ref(fn, WEBEXT.fileSystem.isWritableEntry);
   301      },
   302      "call_IsWritableEntry": (retPtr: Pointer, entry: heap.Ref<object>): void => {
   303        const _ret = WEBEXT.fileSystem.isWritableEntry(A.H.get<object>(entry));
   304        A.store.Ref(retPtr, _ret);
   305      },
   306      "try_IsWritableEntry": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => {
   307        try {
   308          const _ret = WEBEXT.fileSystem.isWritableEntry(A.H.get<object>(entry));
   309          A.store.Ref(retPtr, _ret);
   310          return A.H.TRUE;
   311        } catch (err: any) {
   312          A.store.Ref(errPtr, err);
   313          return A.H.FALSE;
   314        }
   315      },
   316      "has_OnVolumeListChanged": (): heap.Ref<boolean> => {
   317        if (WEBEXT?.fileSystem?.onVolumeListChanged && "addListener" in WEBEXT?.fileSystem?.onVolumeListChanged) {
   318          return A.H.TRUE;
   319        }
   320        return A.H.FALSE;
   321      },
   322      "func_OnVolumeListChanged": (fn: Pointer): void => {
   323        A.store.Ref(fn, WEBEXT.fileSystem.onVolumeListChanged.addListener);
   324      },
   325      "call_OnVolumeListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   326        const _ret = WEBEXT.fileSystem.onVolumeListChanged.addListener(A.H.get<object>(callback));
   327      },
   328      "try_OnVolumeListChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   329        try {
   330          const _ret = WEBEXT.fileSystem.onVolumeListChanged.addListener(A.H.get<object>(callback));
   331          return A.H.TRUE;
   332        } catch (err: any) {
   333          A.store.Ref(errPtr, err);
   334          return A.H.FALSE;
   335        }
   336      },
   337      "has_OffVolumeListChanged": (): heap.Ref<boolean> => {
   338        if (WEBEXT?.fileSystem?.onVolumeListChanged && "removeListener" in WEBEXT?.fileSystem?.onVolumeListChanged) {
   339          return A.H.TRUE;
   340        }
   341        return A.H.FALSE;
   342      },
   343      "func_OffVolumeListChanged": (fn: Pointer): void => {
   344        A.store.Ref(fn, WEBEXT.fileSystem.onVolumeListChanged.removeListener);
   345      },
   346      "call_OffVolumeListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   347        const _ret = WEBEXT.fileSystem.onVolumeListChanged.removeListener(A.H.get<object>(callback));
   348      },
   349      "try_OffVolumeListChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   350        try {
   351          const _ret = WEBEXT.fileSystem.onVolumeListChanged.removeListener(A.H.get<object>(callback));
   352          return A.H.TRUE;
   353        } catch (err: any) {
   354          A.store.Ref(errPtr, err);
   355          return A.H.FALSE;
   356        }
   357      },
   358      "has_HasOnVolumeListChanged": (): heap.Ref<boolean> => {
   359        if (WEBEXT?.fileSystem?.onVolumeListChanged && "hasListener" in WEBEXT?.fileSystem?.onVolumeListChanged) {
   360          return A.H.TRUE;
   361        }
   362        return A.H.FALSE;
   363      },
   364      "func_HasOnVolumeListChanged": (fn: Pointer): void => {
   365        A.store.Ref(fn, WEBEXT.fileSystem.onVolumeListChanged.hasListener);
   366      },
   367      "call_HasOnVolumeListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   368        const _ret = WEBEXT.fileSystem.onVolumeListChanged.hasListener(A.H.get<object>(callback));
   369        A.store.Bool(retPtr, _ret);
   370      },
   371      "try_HasOnVolumeListChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   372        try {
   373          const _ret = WEBEXT.fileSystem.onVolumeListChanged.hasListener(A.H.get<object>(callback));
   374          A.store.Bool(retPtr, _ret);
   375          return A.H.TRUE;
   376        } catch (err: any) {
   377          A.store.Ref(errPtr, err);
   378          return A.H.FALSE;
   379        }
   380      },
   381      "has_RequestFileSystem": (): heap.Ref<boolean> => {
   382        if (WEBEXT?.fileSystem && "requestFileSystem" in WEBEXT?.fileSystem) {
   383          return A.H.TRUE;
   384        }
   385        return A.H.FALSE;
   386      },
   387      "func_RequestFileSystem": (fn: Pointer): void => {
   388        A.store.Ref(fn, WEBEXT.fileSystem.requestFileSystem);
   389      },
   390      "call_RequestFileSystem": (retPtr: Pointer, options: Pointer): void => {
   391        const options_ffi = {};
   392  
   393        options_ffi["volumeId"] = A.load.Ref(options + 0, undefined);
   394        if (A.load.Bool(options + 5)) {
   395          options_ffi["writable"] = A.load.Bool(options + 4);
   396        }
   397  
   398        const _ret = WEBEXT.fileSystem.requestFileSystem(options_ffi);
   399        A.store.Ref(retPtr, _ret);
   400      },
   401      "try_RequestFileSystem": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => {
   402        try {
   403          const options_ffi = {};
   404  
   405          options_ffi["volumeId"] = A.load.Ref(options + 0, undefined);
   406          if (A.load.Bool(options + 5)) {
   407            options_ffi["writable"] = A.load.Bool(options + 4);
   408          }
   409  
   410          const _ret = WEBEXT.fileSystem.requestFileSystem(options_ffi);
   411          A.store.Ref(retPtr, _ret);
   412          return A.H.TRUE;
   413        } catch (err: any) {
   414          A.store.Ref(errPtr, err);
   415          return A.H.FALSE;
   416        }
   417      },
   418      "has_RestoreEntry": (): heap.Ref<boolean> => {
   419        if (WEBEXT?.fileSystem && "restoreEntry" in WEBEXT?.fileSystem) {
   420          return A.H.TRUE;
   421        }
   422        return A.H.FALSE;
   423      },
   424      "func_RestoreEntry": (fn: Pointer): void => {
   425        A.store.Ref(fn, WEBEXT.fileSystem.restoreEntry);
   426      },
   427      "call_RestoreEntry": (retPtr: Pointer, id: heap.Ref<object>, callback: heap.Ref<object>): void => {
   428        const _ret = WEBEXT.fileSystem.restoreEntry(A.H.get<object>(id), A.H.get<object>(callback));
   429      },
   430      "try_RestoreEntry": (
   431        retPtr: Pointer,
   432        errPtr: Pointer,
   433        id: heap.Ref<object>,
   434        callback: heap.Ref<object>
   435      ): heap.Ref<boolean> => {
   436        try {
   437          const _ret = WEBEXT.fileSystem.restoreEntry(A.H.get<object>(id), A.H.get<object>(callback));
   438          return A.H.TRUE;
   439        } catch (err: any) {
   440          A.store.Ref(errPtr, err);
   441          return A.H.FALSE;
   442        }
   443      },
   444      "has_RetainEntry": (): heap.Ref<boolean> => {
   445        if (WEBEXT?.fileSystem && "retainEntry" in WEBEXT?.fileSystem) {
   446          return A.H.TRUE;
   447        }
   448        return A.H.FALSE;
   449      },
   450      "func_RetainEntry": (fn: Pointer): void => {
   451        A.store.Ref(fn, WEBEXT.fileSystem.retainEntry);
   452      },
   453      "call_RetainEntry": (retPtr: Pointer, entry: heap.Ref<object>): void => {
   454        const _ret = WEBEXT.fileSystem.retainEntry(A.H.get<object>(entry));
   455        A.store.Ref(retPtr, _ret);
   456      },
   457      "try_RetainEntry": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => {
   458        try {
   459          const _ret = WEBEXT.fileSystem.retainEntry(A.H.get<object>(entry));
   460          A.store.Ref(retPtr, _ret);
   461          return A.H.TRUE;
   462        } catch (err: any) {
   463          A.store.Ref(errPtr, err);
   464          return A.H.FALSE;
   465        }
   466      },
   467    };
   468  });