github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/system/storage/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/system/storage", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_EjectDeviceResultCode": (ref: heap.Ref<string>): number => { 8 const idx = ["success", "in_use", "no_such_device", "failure"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 12 "store_StorageAvailableCapacityInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 13 const x = A.H.get<any>(ref); 14 15 if (typeof x === "undefined") { 16 A.store.Bool(ptr + 17, false); 17 A.store.Ref(ptr + 0, undefined); 18 A.store.Bool(ptr + 16, false); 19 A.store.Float64(ptr + 8, 0); 20 } else { 21 A.store.Bool(ptr + 17, true); 22 A.store.Ref(ptr + 0, x["id"]); 23 A.store.Bool(ptr + 16, "availableCapacity" in x ? true : false); 24 A.store.Float64(ptr + 8, x["availableCapacity"] === undefined ? 0 : (x["availableCapacity"] as number)); 25 } 26 }, 27 "load_StorageAvailableCapacityInfo": ( 28 ptr: Pointer, 29 create: heap.Ref<boolean>, 30 ref: heap.Ref<any> 31 ): heap.Ref<any> => { 32 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 33 34 x["id"] = A.load.Ref(ptr + 0, undefined); 35 if (A.load.Bool(ptr + 16)) { 36 x["availableCapacity"] = A.load.Float64(ptr + 8); 37 } else { 38 delete x["availableCapacity"]; 39 } 40 return create === A.H.TRUE ? A.H.push(x) : ref; 41 }, 42 "constof_StorageUnitType": (ref: heap.Ref<string>): number => { 43 const idx = ["fixed", "removable", "unknown"].indexOf(A.H.get(ref)); 44 return idx < 0 ? 0 : idx + 1; 45 }, 46 47 "store_StorageUnitInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 48 const x = A.H.get<any>(ref); 49 50 if (typeof x === "undefined") { 51 A.store.Bool(ptr + 25, false); 52 A.store.Ref(ptr + 0, undefined); 53 A.store.Ref(ptr + 4, undefined); 54 A.store.Enum(ptr + 8, -1); 55 A.store.Bool(ptr + 24, false); 56 A.store.Float64(ptr + 16, 0); 57 } else { 58 A.store.Bool(ptr + 25, true); 59 A.store.Ref(ptr + 0, x["id"]); 60 A.store.Ref(ptr + 4, x["name"]); 61 A.store.Enum(ptr + 8, ["fixed", "removable", "unknown"].indexOf(x["type"] as string)); 62 A.store.Bool(ptr + 24, "capacity" in x ? true : false); 63 A.store.Float64(ptr + 16, x["capacity"] === undefined ? 0 : (x["capacity"] as number)); 64 } 65 }, 66 "load_StorageUnitInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 67 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 68 69 x["id"] = A.load.Ref(ptr + 0, undefined); 70 x["name"] = A.load.Ref(ptr + 4, undefined); 71 x["type"] = A.load.Enum(ptr + 8, ["fixed", "removable", "unknown"]); 72 if (A.load.Bool(ptr + 24)) { 73 x["capacity"] = A.load.Float64(ptr + 16); 74 } else { 75 delete x["capacity"]; 76 } 77 return create === A.H.TRUE ? A.H.push(x) : ref; 78 }, 79 "has_EjectDevice": (): heap.Ref<boolean> => { 80 if (WEBEXT?.system?.storage && "ejectDevice" in WEBEXT?.system?.storage) { 81 return A.H.TRUE; 82 } 83 return A.H.FALSE; 84 }, 85 "func_EjectDevice": (fn: Pointer): void => { 86 A.store.Ref(fn, WEBEXT.system.storage.ejectDevice); 87 }, 88 "call_EjectDevice": (retPtr: Pointer, id: heap.Ref<object>): void => { 89 const _ret = WEBEXT.system.storage.ejectDevice(A.H.get<object>(id)); 90 A.store.Ref(retPtr, _ret); 91 }, 92 "try_EjectDevice": (retPtr: Pointer, errPtr: Pointer, id: heap.Ref<object>): heap.Ref<boolean> => { 93 try { 94 const _ret = WEBEXT.system.storage.ejectDevice(A.H.get<object>(id)); 95 A.store.Ref(retPtr, _ret); 96 return A.H.TRUE; 97 } catch (err: any) { 98 A.store.Ref(errPtr, err); 99 return A.H.FALSE; 100 } 101 }, 102 "has_GetAvailableCapacity": (): heap.Ref<boolean> => { 103 if (WEBEXT?.system?.storage && "getAvailableCapacity" in WEBEXT?.system?.storage) { 104 return A.H.TRUE; 105 } 106 return A.H.FALSE; 107 }, 108 "func_GetAvailableCapacity": (fn: Pointer): void => { 109 A.store.Ref(fn, WEBEXT.system.storage.getAvailableCapacity); 110 }, 111 "call_GetAvailableCapacity": (retPtr: Pointer, id: heap.Ref<object>): void => { 112 const _ret = WEBEXT.system.storage.getAvailableCapacity(A.H.get<object>(id)); 113 A.store.Ref(retPtr, _ret); 114 }, 115 "try_GetAvailableCapacity": (retPtr: Pointer, errPtr: Pointer, id: heap.Ref<object>): heap.Ref<boolean> => { 116 try { 117 const _ret = WEBEXT.system.storage.getAvailableCapacity(A.H.get<object>(id)); 118 A.store.Ref(retPtr, _ret); 119 return A.H.TRUE; 120 } catch (err: any) { 121 A.store.Ref(errPtr, err); 122 return A.H.FALSE; 123 } 124 }, 125 "has_GetInfo": (): heap.Ref<boolean> => { 126 if (WEBEXT?.system?.storage && "getInfo" in WEBEXT?.system?.storage) { 127 return A.H.TRUE; 128 } 129 return A.H.FALSE; 130 }, 131 "func_GetInfo": (fn: Pointer): void => { 132 A.store.Ref(fn, WEBEXT.system.storage.getInfo); 133 }, 134 "call_GetInfo": (retPtr: Pointer): void => { 135 const _ret = WEBEXT.system.storage.getInfo(); 136 A.store.Ref(retPtr, _ret); 137 }, 138 "try_GetInfo": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 139 try { 140 const _ret = WEBEXT.system.storage.getInfo(); 141 A.store.Ref(retPtr, _ret); 142 return A.H.TRUE; 143 } catch (err: any) { 144 A.store.Ref(errPtr, err); 145 return A.H.FALSE; 146 } 147 }, 148 "has_OnAttached": (): heap.Ref<boolean> => { 149 if (WEBEXT?.system?.storage?.onAttached && "addListener" in WEBEXT?.system?.storage?.onAttached) { 150 return A.H.TRUE; 151 } 152 return A.H.FALSE; 153 }, 154 "func_OnAttached": (fn: Pointer): void => { 155 A.store.Ref(fn, WEBEXT.system.storage.onAttached.addListener); 156 }, 157 "call_OnAttached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 158 const _ret = WEBEXT.system.storage.onAttached.addListener(A.H.get<object>(callback)); 159 }, 160 "try_OnAttached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 161 try { 162 const _ret = WEBEXT.system.storage.onAttached.addListener(A.H.get<object>(callback)); 163 return A.H.TRUE; 164 } catch (err: any) { 165 A.store.Ref(errPtr, err); 166 return A.H.FALSE; 167 } 168 }, 169 "has_OffAttached": (): heap.Ref<boolean> => { 170 if (WEBEXT?.system?.storage?.onAttached && "removeListener" in WEBEXT?.system?.storage?.onAttached) { 171 return A.H.TRUE; 172 } 173 return A.H.FALSE; 174 }, 175 "func_OffAttached": (fn: Pointer): void => { 176 A.store.Ref(fn, WEBEXT.system.storage.onAttached.removeListener); 177 }, 178 "call_OffAttached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 179 const _ret = WEBEXT.system.storage.onAttached.removeListener(A.H.get<object>(callback)); 180 }, 181 "try_OffAttached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 182 try { 183 const _ret = WEBEXT.system.storage.onAttached.removeListener(A.H.get<object>(callback)); 184 return A.H.TRUE; 185 } catch (err: any) { 186 A.store.Ref(errPtr, err); 187 return A.H.FALSE; 188 } 189 }, 190 "has_HasOnAttached": (): heap.Ref<boolean> => { 191 if (WEBEXT?.system?.storage?.onAttached && "hasListener" in WEBEXT?.system?.storage?.onAttached) { 192 return A.H.TRUE; 193 } 194 return A.H.FALSE; 195 }, 196 "func_HasOnAttached": (fn: Pointer): void => { 197 A.store.Ref(fn, WEBEXT.system.storage.onAttached.hasListener); 198 }, 199 "call_HasOnAttached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 200 const _ret = WEBEXT.system.storage.onAttached.hasListener(A.H.get<object>(callback)); 201 A.store.Bool(retPtr, _ret); 202 }, 203 "try_HasOnAttached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 204 try { 205 const _ret = WEBEXT.system.storage.onAttached.hasListener(A.H.get<object>(callback)); 206 A.store.Bool(retPtr, _ret); 207 return A.H.TRUE; 208 } catch (err: any) { 209 A.store.Ref(errPtr, err); 210 return A.H.FALSE; 211 } 212 }, 213 "has_OnDetached": (): heap.Ref<boolean> => { 214 if (WEBEXT?.system?.storage?.onDetached && "addListener" in WEBEXT?.system?.storage?.onDetached) { 215 return A.H.TRUE; 216 } 217 return A.H.FALSE; 218 }, 219 "func_OnDetached": (fn: Pointer): void => { 220 A.store.Ref(fn, WEBEXT.system.storage.onDetached.addListener); 221 }, 222 "call_OnDetached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 223 const _ret = WEBEXT.system.storage.onDetached.addListener(A.H.get<object>(callback)); 224 }, 225 "try_OnDetached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 226 try { 227 const _ret = WEBEXT.system.storage.onDetached.addListener(A.H.get<object>(callback)); 228 return A.H.TRUE; 229 } catch (err: any) { 230 A.store.Ref(errPtr, err); 231 return A.H.FALSE; 232 } 233 }, 234 "has_OffDetached": (): heap.Ref<boolean> => { 235 if (WEBEXT?.system?.storage?.onDetached && "removeListener" in WEBEXT?.system?.storage?.onDetached) { 236 return A.H.TRUE; 237 } 238 return A.H.FALSE; 239 }, 240 "func_OffDetached": (fn: Pointer): void => { 241 A.store.Ref(fn, WEBEXT.system.storage.onDetached.removeListener); 242 }, 243 "call_OffDetached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 244 const _ret = WEBEXT.system.storage.onDetached.removeListener(A.H.get<object>(callback)); 245 }, 246 "try_OffDetached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 247 try { 248 const _ret = WEBEXT.system.storage.onDetached.removeListener(A.H.get<object>(callback)); 249 return A.H.TRUE; 250 } catch (err: any) { 251 A.store.Ref(errPtr, err); 252 return A.H.FALSE; 253 } 254 }, 255 "has_HasOnDetached": (): heap.Ref<boolean> => { 256 if (WEBEXT?.system?.storage?.onDetached && "hasListener" in WEBEXT?.system?.storage?.onDetached) { 257 return A.H.TRUE; 258 } 259 return A.H.FALSE; 260 }, 261 "func_HasOnDetached": (fn: Pointer): void => { 262 A.store.Ref(fn, WEBEXT.system.storage.onDetached.hasListener); 263 }, 264 "call_HasOnDetached": (retPtr: Pointer, callback: heap.Ref<object>): void => { 265 const _ret = WEBEXT.system.storage.onDetached.hasListener(A.H.get<object>(callback)); 266 A.store.Bool(retPtr, _ret); 267 }, 268 "try_HasOnDetached": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 269 try { 270 const _ret = WEBEXT.system.storage.onDetached.hasListener(A.H.get<object>(callback)); 271 A.store.Bool(retPtr, _ret); 272 return A.H.TRUE; 273 } catch (err: any) { 274 A.store.Ref(errPtr, err); 275 return A.H.FALSE; 276 } 277 }, 278 }; 279 });