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 });