github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/socket/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/socket", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_AcceptInfo": (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 + 10, false); 12 A.store.Bool(ptr + 8, false); 13 A.store.Int32(ptr + 0, 0); 14 A.store.Bool(ptr + 9, false); 15 A.store.Int32(ptr + 4, 0); 16 } else { 17 A.store.Bool(ptr + 10, true); 18 A.store.Bool(ptr + 8, "resultCode" in x ? true : false); 19 A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number)); 20 A.store.Bool(ptr + 9, "socketId" in x ? true : false); 21 A.store.Int32(ptr + 4, x["socketId"] === undefined ? 0 : (x["socketId"] as number)); 22 } 23 }, 24 "load_AcceptInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 25 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 26 27 if (A.load.Bool(ptr + 8)) { 28 x["resultCode"] = A.load.Int32(ptr + 0); 29 } else { 30 delete x["resultCode"]; 31 } 32 if (A.load.Bool(ptr + 9)) { 33 x["socketId"] = A.load.Int32(ptr + 4); 34 } else { 35 delete x["socketId"]; 36 } 37 return create === A.H.TRUE ? A.H.push(x) : ref; 38 }, 39 40 "store_CreateInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 41 const x = A.H.get<any>(ref); 42 43 if (typeof x === "undefined") { 44 A.store.Bool(ptr + 5, false); 45 A.store.Bool(ptr + 4, false); 46 A.store.Int32(ptr + 0, 0); 47 } else { 48 A.store.Bool(ptr + 5, true); 49 A.store.Bool(ptr + 4, "socketId" in x ? true : false); 50 A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number)); 51 } 52 }, 53 "load_CreateInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 54 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 55 56 if (A.load.Bool(ptr + 4)) { 57 x["socketId"] = A.load.Int32(ptr + 0); 58 } else { 59 delete x["socketId"]; 60 } 61 return create === A.H.TRUE ? A.H.push(x) : ref; 62 }, 63 64 "store_CreateOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 65 const x = A.H.get<any>(ref); 66 67 if (typeof x === "undefined") { 68 A.store.Bool(ptr + 0, false); 69 } else { 70 A.store.Bool(ptr + 0, true); 71 } 72 }, 73 "load_CreateOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 74 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 75 76 return create === A.H.TRUE ? A.H.push(x) : ref; 77 }, 78 "constof_SocketType": (ref: heap.Ref<string>): number => { 79 const idx = ["tcp", "udp"].indexOf(A.H.get(ref)); 80 return idx < 0 ? 0 : idx + 1; 81 }, 82 83 "store_SocketInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 84 const x = A.H.get<any>(ref); 85 86 if (typeof x === "undefined") { 87 A.store.Bool(ptr + 27, false); 88 A.store.Enum(ptr + 0, -1); 89 A.store.Bool(ptr + 24, false); 90 A.store.Bool(ptr + 4, false); 91 A.store.Ref(ptr + 8, undefined); 92 A.store.Bool(ptr + 25, false); 93 A.store.Int32(ptr + 12, 0); 94 A.store.Ref(ptr + 16, undefined); 95 A.store.Bool(ptr + 26, false); 96 A.store.Int32(ptr + 20, 0); 97 } else { 98 A.store.Bool(ptr + 27, true); 99 A.store.Enum(ptr + 0, ["tcp", "udp"].indexOf(x["socketType"] as string)); 100 A.store.Bool(ptr + 24, "connected" in x ? true : false); 101 A.store.Bool(ptr + 4, x["connected"] ? true : false); 102 A.store.Ref(ptr + 8, x["peerAddress"]); 103 A.store.Bool(ptr + 25, "peerPort" in x ? true : false); 104 A.store.Int32(ptr + 12, x["peerPort"] === undefined ? 0 : (x["peerPort"] as number)); 105 A.store.Ref(ptr + 16, x["localAddress"]); 106 A.store.Bool(ptr + 26, "localPort" in x ? true : false); 107 A.store.Int32(ptr + 20, x["localPort"] === undefined ? 0 : (x["localPort"] as number)); 108 } 109 }, 110 "load_SocketInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 111 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 112 113 x["socketType"] = A.load.Enum(ptr + 0, ["tcp", "udp"]); 114 if (A.load.Bool(ptr + 24)) { 115 x["connected"] = A.load.Bool(ptr + 4); 116 } else { 117 delete x["connected"]; 118 } 119 x["peerAddress"] = A.load.Ref(ptr + 8, undefined); 120 if (A.load.Bool(ptr + 25)) { 121 x["peerPort"] = A.load.Int32(ptr + 12); 122 } else { 123 delete x["peerPort"]; 124 } 125 x["localAddress"] = A.load.Ref(ptr + 16, undefined); 126 if (A.load.Bool(ptr + 26)) { 127 x["localPort"] = A.load.Int32(ptr + 20); 128 } else { 129 delete x["localPort"]; 130 } 131 return create === A.H.TRUE ? A.H.push(x) : ref; 132 }, 133 134 "store_NetworkInterface": (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 + 13, false); 139 A.store.Ref(ptr + 0, undefined); 140 A.store.Ref(ptr + 4, undefined); 141 A.store.Bool(ptr + 12, false); 142 A.store.Int32(ptr + 8, 0); 143 } else { 144 A.store.Bool(ptr + 13, true); 145 A.store.Ref(ptr + 0, x["name"]); 146 A.store.Ref(ptr + 4, x["address"]); 147 A.store.Bool(ptr + 12, "prefixLength" in x ? true : false); 148 A.store.Int32(ptr + 8, x["prefixLength"] === undefined ? 0 : (x["prefixLength"] as number)); 149 } 150 }, 151 "load_NetworkInterface": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 152 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 153 154 x["name"] = A.load.Ref(ptr + 0, undefined); 155 x["address"] = A.load.Ref(ptr + 4, undefined); 156 if (A.load.Bool(ptr + 12)) { 157 x["prefixLength"] = A.load.Int32(ptr + 8); 158 } else { 159 delete x["prefixLength"]; 160 } 161 return create === A.H.TRUE ? A.H.push(x) : ref; 162 }, 163 164 "store_ReadInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 165 const x = A.H.get<any>(ref); 166 167 if (typeof x === "undefined") { 168 A.store.Bool(ptr + 9, false); 169 A.store.Bool(ptr + 8, false); 170 A.store.Int32(ptr + 0, 0); 171 A.store.Ref(ptr + 4, undefined); 172 } else { 173 A.store.Bool(ptr + 9, true); 174 A.store.Bool(ptr + 8, "resultCode" in x ? true : false); 175 A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number)); 176 A.store.Ref(ptr + 4, x["data"]); 177 } 178 }, 179 "load_ReadInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 180 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 181 182 if (A.load.Bool(ptr + 8)) { 183 x["resultCode"] = A.load.Int32(ptr + 0); 184 } else { 185 delete x["resultCode"]; 186 } 187 x["data"] = A.load.Ref(ptr + 4, undefined); 188 return create === A.H.TRUE ? A.H.push(x) : ref; 189 }, 190 191 "store_RecvFromInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 192 const x = A.H.get<any>(ref); 193 194 if (typeof x === "undefined") { 195 A.store.Bool(ptr + 18, false); 196 A.store.Bool(ptr + 16, false); 197 A.store.Int32(ptr + 0, 0); 198 A.store.Ref(ptr + 4, undefined); 199 A.store.Ref(ptr + 8, undefined); 200 A.store.Bool(ptr + 17, false); 201 A.store.Int32(ptr + 12, 0); 202 } else { 203 A.store.Bool(ptr + 18, true); 204 A.store.Bool(ptr + 16, "resultCode" in x ? true : false); 205 A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number)); 206 A.store.Ref(ptr + 4, x["data"]); 207 A.store.Ref(ptr + 8, x["address"]); 208 A.store.Bool(ptr + 17, "port" in x ? true : false); 209 A.store.Int32(ptr + 12, x["port"] === undefined ? 0 : (x["port"] as number)); 210 } 211 }, 212 "load_RecvFromInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 213 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 214 215 if (A.load.Bool(ptr + 16)) { 216 x["resultCode"] = A.load.Int32(ptr + 0); 217 } else { 218 delete x["resultCode"]; 219 } 220 x["data"] = A.load.Ref(ptr + 4, undefined); 221 x["address"] = A.load.Ref(ptr + 8, undefined); 222 if (A.load.Bool(ptr + 17)) { 223 x["port"] = A.load.Int32(ptr + 12); 224 } else { 225 delete x["port"]; 226 } 227 return create === A.H.TRUE ? A.H.push(x) : ref; 228 }, 229 230 "store_TLSVersionConstraints": (ptr: Pointer, ref: heap.Ref<any>) => { 231 const x = A.H.get<any>(ref); 232 233 if (typeof x === "undefined") { 234 A.store.Bool(ptr + 8, false); 235 A.store.Ref(ptr + 0, undefined); 236 A.store.Ref(ptr + 4, undefined); 237 } else { 238 A.store.Bool(ptr + 8, true); 239 A.store.Ref(ptr + 0, x["min"]); 240 A.store.Ref(ptr + 4, x["max"]); 241 } 242 }, 243 "load_TLSVersionConstraints": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 244 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 245 246 x["min"] = A.load.Ref(ptr + 0, undefined); 247 x["max"] = A.load.Ref(ptr + 4, undefined); 248 return create === A.H.TRUE ? A.H.push(x) : ref; 249 }, 250 251 "store_SecureOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 252 const x = A.H.get<any>(ref); 253 254 if (typeof x === "undefined") { 255 A.store.Bool(ptr + 9, false); 256 257 A.store.Bool(ptr + 0 + 8, false); 258 A.store.Ref(ptr + 0 + 0, undefined); 259 A.store.Ref(ptr + 0 + 4, undefined); 260 } else { 261 A.store.Bool(ptr + 9, true); 262 263 if (typeof x["tlsVersion"] === "undefined") { 264 A.store.Bool(ptr + 0 + 8, false); 265 A.store.Ref(ptr + 0 + 0, undefined); 266 A.store.Ref(ptr + 0 + 4, undefined); 267 } else { 268 A.store.Bool(ptr + 0 + 8, true); 269 A.store.Ref(ptr + 0 + 0, x["tlsVersion"]["min"]); 270 A.store.Ref(ptr + 0 + 4, x["tlsVersion"]["max"]); 271 } 272 } 273 }, 274 "load_SecureOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 275 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 276 277 if (A.load.Bool(ptr + 0 + 8)) { 278 x["tlsVersion"] = {}; 279 x["tlsVersion"]["min"] = A.load.Ref(ptr + 0 + 0, undefined); 280 x["tlsVersion"]["max"] = A.load.Ref(ptr + 0 + 4, undefined); 281 } else { 282 delete x["tlsVersion"]; 283 } 284 return create === A.H.TRUE ? A.H.push(x) : ref; 285 }, 286 287 "store_WriteInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 288 const x = A.H.get<any>(ref); 289 290 if (typeof x === "undefined") { 291 A.store.Bool(ptr + 5, false); 292 A.store.Bool(ptr + 4, false); 293 A.store.Int32(ptr + 0, 0); 294 } else { 295 A.store.Bool(ptr + 5, true); 296 A.store.Bool(ptr + 4, "bytesWritten" in x ? true : false); 297 A.store.Int32(ptr + 0, x["bytesWritten"] === undefined ? 0 : (x["bytesWritten"] as number)); 298 } 299 }, 300 "load_WriteInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 301 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 302 303 if (A.load.Bool(ptr + 4)) { 304 x["bytesWritten"] = A.load.Int32(ptr + 0); 305 } else { 306 delete x["bytesWritten"]; 307 } 308 return create === A.H.TRUE ? A.H.push(x) : ref; 309 }, 310 "has_Accept": (): heap.Ref<boolean> => { 311 if (WEBEXT?.socket && "accept" in WEBEXT?.socket) { 312 return A.H.TRUE; 313 } 314 return A.H.FALSE; 315 }, 316 "func_Accept": (fn: Pointer): void => { 317 A.store.Ref(fn, WEBEXT.socket.accept); 318 }, 319 "call_Accept": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => { 320 const _ret = WEBEXT.socket.accept(socketId, A.H.get<object>(callback)); 321 }, 322 "try_Accept": ( 323 retPtr: Pointer, 324 errPtr: Pointer, 325 socketId: number, 326 callback: heap.Ref<object> 327 ): heap.Ref<boolean> => { 328 try { 329 const _ret = WEBEXT.socket.accept(socketId, A.H.get<object>(callback)); 330 return A.H.TRUE; 331 } catch (err: any) { 332 A.store.Ref(errPtr, err); 333 return A.H.FALSE; 334 } 335 }, 336 "has_Bind": (): heap.Ref<boolean> => { 337 if (WEBEXT?.socket && "bind" in WEBEXT?.socket) { 338 return A.H.TRUE; 339 } 340 return A.H.FALSE; 341 }, 342 "func_Bind": (fn: Pointer): void => { 343 A.store.Ref(fn, WEBEXT.socket.bind); 344 }, 345 "call_Bind": ( 346 retPtr: Pointer, 347 socketId: number, 348 address: heap.Ref<object>, 349 port: number, 350 callback: heap.Ref<object> 351 ): void => { 352 const _ret = WEBEXT.socket.bind(socketId, A.H.get<object>(address), port, A.H.get<object>(callback)); 353 }, 354 "try_Bind": ( 355 retPtr: Pointer, 356 errPtr: Pointer, 357 socketId: number, 358 address: heap.Ref<object>, 359 port: number, 360 callback: heap.Ref<object> 361 ): heap.Ref<boolean> => { 362 try { 363 const _ret = WEBEXT.socket.bind(socketId, A.H.get<object>(address), port, A.H.get<object>(callback)); 364 return A.H.TRUE; 365 } catch (err: any) { 366 A.store.Ref(errPtr, err); 367 return A.H.FALSE; 368 } 369 }, 370 "has_Connect": (): heap.Ref<boolean> => { 371 if (WEBEXT?.socket && "connect" in WEBEXT?.socket) { 372 return A.H.TRUE; 373 } 374 return A.H.FALSE; 375 }, 376 "func_Connect": (fn: Pointer): void => { 377 A.store.Ref(fn, WEBEXT.socket.connect); 378 }, 379 "call_Connect": ( 380 retPtr: Pointer, 381 socketId: number, 382 hostname: heap.Ref<object>, 383 port: number, 384 callback: heap.Ref<object> 385 ): void => { 386 const _ret = WEBEXT.socket.connect(socketId, A.H.get<object>(hostname), port, A.H.get<object>(callback)); 387 }, 388 "try_Connect": ( 389 retPtr: Pointer, 390 errPtr: Pointer, 391 socketId: number, 392 hostname: heap.Ref<object>, 393 port: number, 394 callback: heap.Ref<object> 395 ): heap.Ref<boolean> => { 396 try { 397 const _ret = WEBEXT.socket.connect(socketId, A.H.get<object>(hostname), port, A.H.get<object>(callback)); 398 return A.H.TRUE; 399 } catch (err: any) { 400 A.store.Ref(errPtr, err); 401 return A.H.FALSE; 402 } 403 }, 404 "has_Create": (): heap.Ref<boolean> => { 405 if (WEBEXT?.socket && "create" in WEBEXT?.socket) { 406 return A.H.TRUE; 407 } 408 return A.H.FALSE; 409 }, 410 "func_Create": (fn: Pointer): void => { 411 A.store.Ref(fn, WEBEXT.socket.create); 412 }, 413 "call_Create": (retPtr: Pointer, type: number, options: Pointer, callback: heap.Ref<object>): void => { 414 const options_ffi = {}; 415 416 const _ret = WEBEXT.socket.create( 417 type > 0 && type <= 2 ? ["tcp", "udp"][type - 1] : undefined, 418 options_ffi, 419 A.H.get<object>(callback) 420 ); 421 }, 422 "try_Create": ( 423 retPtr: Pointer, 424 errPtr: Pointer, 425 type: number, 426 options: Pointer, 427 callback: heap.Ref<object> 428 ): heap.Ref<boolean> => { 429 try { 430 const options_ffi = {}; 431 432 const _ret = WEBEXT.socket.create( 433 type > 0 && type <= 2 ? ["tcp", "udp"][type - 1] : undefined, 434 options_ffi, 435 A.H.get<object>(callback) 436 ); 437 return A.H.TRUE; 438 } catch (err: any) { 439 A.store.Ref(errPtr, err); 440 return A.H.FALSE; 441 } 442 }, 443 "has_Destroy": (): heap.Ref<boolean> => { 444 if (WEBEXT?.socket && "destroy" in WEBEXT?.socket) { 445 return A.H.TRUE; 446 } 447 return A.H.FALSE; 448 }, 449 "func_Destroy": (fn: Pointer): void => { 450 A.store.Ref(fn, WEBEXT.socket.destroy); 451 }, 452 "call_Destroy": (retPtr: Pointer, socketId: number): void => { 453 const _ret = WEBEXT.socket.destroy(socketId); 454 }, 455 "try_Destroy": (retPtr: Pointer, errPtr: Pointer, socketId: number): heap.Ref<boolean> => { 456 try { 457 const _ret = WEBEXT.socket.destroy(socketId); 458 return A.H.TRUE; 459 } catch (err: any) { 460 A.store.Ref(errPtr, err); 461 return A.H.FALSE; 462 } 463 }, 464 "has_Disconnect": (): heap.Ref<boolean> => { 465 if (WEBEXT?.socket && "disconnect" in WEBEXT?.socket) { 466 return A.H.TRUE; 467 } 468 return A.H.FALSE; 469 }, 470 "func_Disconnect": (fn: Pointer): void => { 471 A.store.Ref(fn, WEBEXT.socket.disconnect); 472 }, 473 "call_Disconnect": (retPtr: Pointer, socketId: number): void => { 474 const _ret = WEBEXT.socket.disconnect(socketId); 475 }, 476 "try_Disconnect": (retPtr: Pointer, errPtr: Pointer, socketId: number): heap.Ref<boolean> => { 477 try { 478 const _ret = WEBEXT.socket.disconnect(socketId); 479 return A.H.TRUE; 480 } catch (err: any) { 481 A.store.Ref(errPtr, err); 482 return A.H.FALSE; 483 } 484 }, 485 "has_GetInfo": (): heap.Ref<boolean> => { 486 if (WEBEXT?.socket && "getInfo" in WEBEXT?.socket) { 487 return A.H.TRUE; 488 } 489 return A.H.FALSE; 490 }, 491 "func_GetInfo": (fn: Pointer): void => { 492 A.store.Ref(fn, WEBEXT.socket.getInfo); 493 }, 494 "call_GetInfo": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => { 495 const _ret = WEBEXT.socket.getInfo(socketId, A.H.get<object>(callback)); 496 }, 497 "try_GetInfo": ( 498 retPtr: Pointer, 499 errPtr: Pointer, 500 socketId: number, 501 callback: heap.Ref<object> 502 ): heap.Ref<boolean> => { 503 try { 504 const _ret = WEBEXT.socket.getInfo(socketId, A.H.get<object>(callback)); 505 return A.H.TRUE; 506 } catch (err: any) { 507 A.store.Ref(errPtr, err); 508 return A.H.FALSE; 509 } 510 }, 511 "has_GetJoinedGroups": (): heap.Ref<boolean> => { 512 if (WEBEXT?.socket && "getJoinedGroups" in WEBEXT?.socket) { 513 return A.H.TRUE; 514 } 515 return A.H.FALSE; 516 }, 517 "func_GetJoinedGroups": (fn: Pointer): void => { 518 A.store.Ref(fn, WEBEXT.socket.getJoinedGroups); 519 }, 520 "call_GetJoinedGroups": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => { 521 const _ret = WEBEXT.socket.getJoinedGroups(socketId, A.H.get<object>(callback)); 522 }, 523 "try_GetJoinedGroups": ( 524 retPtr: Pointer, 525 errPtr: Pointer, 526 socketId: number, 527 callback: heap.Ref<object> 528 ): heap.Ref<boolean> => { 529 try { 530 const _ret = WEBEXT.socket.getJoinedGroups(socketId, A.H.get<object>(callback)); 531 return A.H.TRUE; 532 } catch (err: any) { 533 A.store.Ref(errPtr, err); 534 return A.H.FALSE; 535 } 536 }, 537 "has_GetNetworkList": (): heap.Ref<boolean> => { 538 if (WEBEXT?.socket && "getNetworkList" in WEBEXT?.socket) { 539 return A.H.TRUE; 540 } 541 return A.H.FALSE; 542 }, 543 "func_GetNetworkList": (fn: Pointer): void => { 544 A.store.Ref(fn, WEBEXT.socket.getNetworkList); 545 }, 546 "call_GetNetworkList": (retPtr: Pointer, callback: heap.Ref<object>): void => { 547 const _ret = WEBEXT.socket.getNetworkList(A.H.get<object>(callback)); 548 }, 549 "try_GetNetworkList": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 550 try { 551 const _ret = WEBEXT.socket.getNetworkList(A.H.get<object>(callback)); 552 return A.H.TRUE; 553 } catch (err: any) { 554 A.store.Ref(errPtr, err); 555 return A.H.FALSE; 556 } 557 }, 558 "has_JoinGroup": (): heap.Ref<boolean> => { 559 if (WEBEXT?.socket && "joinGroup" in WEBEXT?.socket) { 560 return A.H.TRUE; 561 } 562 return A.H.FALSE; 563 }, 564 "func_JoinGroup": (fn: Pointer): void => { 565 A.store.Ref(fn, WEBEXT.socket.joinGroup); 566 }, 567 "call_JoinGroup": ( 568 retPtr: Pointer, 569 socketId: number, 570 address: heap.Ref<object>, 571 callback: heap.Ref<object> 572 ): void => { 573 const _ret = WEBEXT.socket.joinGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback)); 574 }, 575 "try_JoinGroup": ( 576 retPtr: Pointer, 577 errPtr: Pointer, 578 socketId: number, 579 address: heap.Ref<object>, 580 callback: heap.Ref<object> 581 ): heap.Ref<boolean> => { 582 try { 583 const _ret = WEBEXT.socket.joinGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback)); 584 return A.H.TRUE; 585 } catch (err: any) { 586 A.store.Ref(errPtr, err); 587 return A.H.FALSE; 588 } 589 }, 590 "has_LeaveGroup": (): heap.Ref<boolean> => { 591 if (WEBEXT?.socket && "leaveGroup" in WEBEXT?.socket) { 592 return A.H.TRUE; 593 } 594 return A.H.FALSE; 595 }, 596 "func_LeaveGroup": (fn: Pointer): void => { 597 A.store.Ref(fn, WEBEXT.socket.leaveGroup); 598 }, 599 "call_LeaveGroup": ( 600 retPtr: Pointer, 601 socketId: number, 602 address: heap.Ref<object>, 603 callback: heap.Ref<object> 604 ): void => { 605 const _ret = WEBEXT.socket.leaveGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback)); 606 }, 607 "try_LeaveGroup": ( 608 retPtr: Pointer, 609 errPtr: Pointer, 610 socketId: number, 611 address: heap.Ref<object>, 612 callback: heap.Ref<object> 613 ): heap.Ref<boolean> => { 614 try { 615 const _ret = WEBEXT.socket.leaveGroup(socketId, A.H.get<object>(address), A.H.get<object>(callback)); 616 return A.H.TRUE; 617 } catch (err: any) { 618 A.store.Ref(errPtr, err); 619 return A.H.FALSE; 620 } 621 }, 622 "has_Listen": (): heap.Ref<boolean> => { 623 if (WEBEXT?.socket && "listen" in WEBEXT?.socket) { 624 return A.H.TRUE; 625 } 626 return A.H.FALSE; 627 }, 628 "func_Listen": (fn: Pointer): void => { 629 A.store.Ref(fn, WEBEXT.socket.listen); 630 }, 631 "call_Listen": ( 632 retPtr: Pointer, 633 socketId: number, 634 address: heap.Ref<object>, 635 port: number, 636 backlog: number, 637 callback: heap.Ref<object> 638 ): void => { 639 const _ret = WEBEXT.socket.listen(socketId, A.H.get<object>(address), port, backlog, A.H.get<object>(callback)); 640 }, 641 "try_Listen": ( 642 retPtr: Pointer, 643 errPtr: Pointer, 644 socketId: number, 645 address: heap.Ref<object>, 646 port: number, 647 backlog: number, 648 callback: heap.Ref<object> 649 ): heap.Ref<boolean> => { 650 try { 651 const _ret = WEBEXT.socket.listen(socketId, A.H.get<object>(address), port, backlog, A.H.get<object>(callback)); 652 return A.H.TRUE; 653 } catch (err: any) { 654 A.store.Ref(errPtr, err); 655 return A.H.FALSE; 656 } 657 }, 658 "has_Read": (): heap.Ref<boolean> => { 659 if (WEBEXT?.socket && "read" in WEBEXT?.socket) { 660 return A.H.TRUE; 661 } 662 return A.H.FALSE; 663 }, 664 "func_Read": (fn: Pointer): void => { 665 A.store.Ref(fn, WEBEXT.socket.read); 666 }, 667 "call_Read": (retPtr: Pointer, socketId: number, bufferSize: number, callback: heap.Ref<object>): void => { 668 const _ret = WEBEXT.socket.read(socketId, bufferSize, A.H.get<object>(callback)); 669 }, 670 "try_Read": ( 671 retPtr: Pointer, 672 errPtr: Pointer, 673 socketId: number, 674 bufferSize: number, 675 callback: heap.Ref<object> 676 ): heap.Ref<boolean> => { 677 try { 678 const _ret = WEBEXT.socket.read(socketId, bufferSize, A.H.get<object>(callback)); 679 return A.H.TRUE; 680 } catch (err: any) { 681 A.store.Ref(errPtr, err); 682 return A.H.FALSE; 683 } 684 }, 685 "has_RecvFrom": (): heap.Ref<boolean> => { 686 if (WEBEXT?.socket && "recvFrom" in WEBEXT?.socket) { 687 return A.H.TRUE; 688 } 689 return A.H.FALSE; 690 }, 691 "func_RecvFrom": (fn: Pointer): void => { 692 A.store.Ref(fn, WEBEXT.socket.recvFrom); 693 }, 694 "call_RecvFrom": (retPtr: Pointer, socketId: number, bufferSize: number, callback: heap.Ref<object>): void => { 695 const _ret = WEBEXT.socket.recvFrom(socketId, bufferSize, A.H.get<object>(callback)); 696 }, 697 "try_RecvFrom": ( 698 retPtr: Pointer, 699 errPtr: Pointer, 700 socketId: number, 701 bufferSize: number, 702 callback: heap.Ref<object> 703 ): heap.Ref<boolean> => { 704 try { 705 const _ret = WEBEXT.socket.recvFrom(socketId, bufferSize, A.H.get<object>(callback)); 706 return A.H.TRUE; 707 } catch (err: any) { 708 A.store.Ref(errPtr, err); 709 return A.H.FALSE; 710 } 711 }, 712 "has_Secure": (): heap.Ref<boolean> => { 713 if (WEBEXT?.socket && "secure" in WEBEXT?.socket) { 714 return A.H.TRUE; 715 } 716 return A.H.FALSE; 717 }, 718 "func_Secure": (fn: Pointer): void => { 719 A.store.Ref(fn, WEBEXT.socket.secure); 720 }, 721 "call_Secure": (retPtr: Pointer, socketId: number, options: Pointer, callback: heap.Ref<object>): void => { 722 const options_ffi = {}; 723 724 if (A.load.Bool(options + 0 + 8)) { 725 options_ffi["tlsVersion"] = {}; 726 options_ffi["tlsVersion"]["min"] = A.load.Ref(options + 0 + 0, undefined); 727 options_ffi["tlsVersion"]["max"] = A.load.Ref(options + 0 + 4, undefined); 728 } 729 730 const _ret = WEBEXT.socket.secure(socketId, options_ffi, A.H.get<object>(callback)); 731 }, 732 "try_Secure": ( 733 retPtr: Pointer, 734 errPtr: Pointer, 735 socketId: number, 736 options: Pointer, 737 callback: heap.Ref<object> 738 ): heap.Ref<boolean> => { 739 try { 740 const options_ffi = {}; 741 742 if (A.load.Bool(options + 0 + 8)) { 743 options_ffi["tlsVersion"] = {}; 744 options_ffi["tlsVersion"]["min"] = A.load.Ref(options + 0 + 0, undefined); 745 options_ffi["tlsVersion"]["max"] = A.load.Ref(options + 0 + 4, undefined); 746 } 747 748 const _ret = WEBEXT.socket.secure(socketId, options_ffi, A.H.get<object>(callback)); 749 return A.H.TRUE; 750 } catch (err: any) { 751 A.store.Ref(errPtr, err); 752 return A.H.FALSE; 753 } 754 }, 755 "has_SendTo": (): heap.Ref<boolean> => { 756 if (WEBEXT?.socket && "sendTo" in WEBEXT?.socket) { 757 return A.H.TRUE; 758 } 759 return A.H.FALSE; 760 }, 761 "func_SendTo": (fn: Pointer): void => { 762 A.store.Ref(fn, WEBEXT.socket.sendTo); 763 }, 764 "call_SendTo": ( 765 retPtr: Pointer, 766 socketId: number, 767 data: heap.Ref<object>, 768 address: heap.Ref<object>, 769 port: number, 770 callback: heap.Ref<object> 771 ): void => { 772 const _ret = WEBEXT.socket.sendTo( 773 socketId, 774 A.H.get<object>(data), 775 A.H.get<object>(address), 776 port, 777 A.H.get<object>(callback) 778 ); 779 }, 780 "try_SendTo": ( 781 retPtr: Pointer, 782 errPtr: Pointer, 783 socketId: number, 784 data: heap.Ref<object>, 785 address: heap.Ref<object>, 786 port: number, 787 callback: heap.Ref<object> 788 ): heap.Ref<boolean> => { 789 try { 790 const _ret = WEBEXT.socket.sendTo( 791 socketId, 792 A.H.get<object>(data), 793 A.H.get<object>(address), 794 port, 795 A.H.get<object>(callback) 796 ); 797 return A.H.TRUE; 798 } catch (err: any) { 799 A.store.Ref(errPtr, err); 800 return A.H.FALSE; 801 } 802 }, 803 "has_SetKeepAlive": (): heap.Ref<boolean> => { 804 if (WEBEXT?.socket && "setKeepAlive" in WEBEXT?.socket) { 805 return A.H.TRUE; 806 } 807 return A.H.FALSE; 808 }, 809 "func_SetKeepAlive": (fn: Pointer): void => { 810 A.store.Ref(fn, WEBEXT.socket.setKeepAlive); 811 }, 812 "call_SetKeepAlive": ( 813 retPtr: Pointer, 814 socketId: number, 815 enable: heap.Ref<boolean>, 816 delay: number, 817 callback: heap.Ref<object> 818 ): void => { 819 const _ret = WEBEXT.socket.setKeepAlive(socketId, enable === A.H.TRUE, delay, A.H.get<object>(callback)); 820 }, 821 "try_SetKeepAlive": ( 822 retPtr: Pointer, 823 errPtr: Pointer, 824 socketId: number, 825 enable: heap.Ref<boolean>, 826 delay: number, 827 callback: heap.Ref<object> 828 ): heap.Ref<boolean> => { 829 try { 830 const _ret = WEBEXT.socket.setKeepAlive(socketId, enable === A.H.TRUE, delay, A.H.get<object>(callback)); 831 return A.H.TRUE; 832 } catch (err: any) { 833 A.store.Ref(errPtr, err); 834 return A.H.FALSE; 835 } 836 }, 837 "has_SetMulticastLoopbackMode": (): heap.Ref<boolean> => { 838 if (WEBEXT?.socket && "setMulticastLoopbackMode" in WEBEXT?.socket) { 839 return A.H.TRUE; 840 } 841 return A.H.FALSE; 842 }, 843 "func_SetMulticastLoopbackMode": (fn: Pointer): void => { 844 A.store.Ref(fn, WEBEXT.socket.setMulticastLoopbackMode); 845 }, 846 "call_SetMulticastLoopbackMode": ( 847 retPtr: Pointer, 848 socketId: number, 849 enabled: heap.Ref<boolean>, 850 callback: heap.Ref<object> 851 ): void => { 852 const _ret = WEBEXT.socket.setMulticastLoopbackMode(socketId, enabled === A.H.TRUE, A.H.get<object>(callback)); 853 }, 854 "try_SetMulticastLoopbackMode": ( 855 retPtr: Pointer, 856 errPtr: Pointer, 857 socketId: number, 858 enabled: heap.Ref<boolean>, 859 callback: heap.Ref<object> 860 ): heap.Ref<boolean> => { 861 try { 862 const _ret = WEBEXT.socket.setMulticastLoopbackMode(socketId, enabled === A.H.TRUE, A.H.get<object>(callback)); 863 return A.H.TRUE; 864 } catch (err: any) { 865 A.store.Ref(errPtr, err); 866 return A.H.FALSE; 867 } 868 }, 869 "has_SetMulticastTimeToLive": (): heap.Ref<boolean> => { 870 if (WEBEXT?.socket && "setMulticastTimeToLive" in WEBEXT?.socket) { 871 return A.H.TRUE; 872 } 873 return A.H.FALSE; 874 }, 875 "func_SetMulticastTimeToLive": (fn: Pointer): void => { 876 A.store.Ref(fn, WEBEXT.socket.setMulticastTimeToLive); 877 }, 878 "call_SetMulticastTimeToLive": ( 879 retPtr: Pointer, 880 socketId: number, 881 ttl: number, 882 callback: heap.Ref<object> 883 ): void => { 884 const _ret = WEBEXT.socket.setMulticastTimeToLive(socketId, ttl, A.H.get<object>(callback)); 885 }, 886 "try_SetMulticastTimeToLive": ( 887 retPtr: Pointer, 888 errPtr: Pointer, 889 socketId: number, 890 ttl: number, 891 callback: heap.Ref<object> 892 ): heap.Ref<boolean> => { 893 try { 894 const _ret = WEBEXT.socket.setMulticastTimeToLive(socketId, ttl, A.H.get<object>(callback)); 895 return A.H.TRUE; 896 } catch (err: any) { 897 A.store.Ref(errPtr, err); 898 return A.H.FALSE; 899 } 900 }, 901 "has_SetNoDelay": (): heap.Ref<boolean> => { 902 if (WEBEXT?.socket && "setNoDelay" in WEBEXT?.socket) { 903 return A.H.TRUE; 904 } 905 return A.H.FALSE; 906 }, 907 "func_SetNoDelay": (fn: Pointer): void => { 908 A.store.Ref(fn, WEBEXT.socket.setNoDelay); 909 }, 910 "call_SetNoDelay": ( 911 retPtr: Pointer, 912 socketId: number, 913 noDelay: heap.Ref<boolean>, 914 callback: heap.Ref<object> 915 ): void => { 916 const _ret = WEBEXT.socket.setNoDelay(socketId, noDelay === A.H.TRUE, A.H.get<object>(callback)); 917 }, 918 "try_SetNoDelay": ( 919 retPtr: Pointer, 920 errPtr: Pointer, 921 socketId: number, 922 noDelay: heap.Ref<boolean>, 923 callback: heap.Ref<object> 924 ): heap.Ref<boolean> => { 925 try { 926 const _ret = WEBEXT.socket.setNoDelay(socketId, noDelay === A.H.TRUE, A.H.get<object>(callback)); 927 return A.H.TRUE; 928 } catch (err: any) { 929 A.store.Ref(errPtr, err); 930 return A.H.FALSE; 931 } 932 }, 933 "has_Write": (): heap.Ref<boolean> => { 934 if (WEBEXT?.socket && "write" in WEBEXT?.socket) { 935 return A.H.TRUE; 936 } 937 return A.H.FALSE; 938 }, 939 "func_Write": (fn: Pointer): void => { 940 A.store.Ref(fn, WEBEXT.socket.write); 941 }, 942 "call_Write": (retPtr: Pointer, socketId: number, data: heap.Ref<object>, callback: heap.Ref<object>): void => { 943 const _ret = WEBEXT.socket.write(socketId, A.H.get<object>(data), A.H.get<object>(callback)); 944 }, 945 "try_Write": ( 946 retPtr: Pointer, 947 errPtr: Pointer, 948 socketId: number, 949 data: heap.Ref<object>, 950 callback: heap.Ref<object> 951 ): heap.Ref<boolean> => { 952 try { 953 const _ret = WEBEXT.socket.write(socketId, A.H.get<object>(data), A.H.get<object>(callback)); 954 return A.H.TRUE; 955 } catch (err: any) { 956 A.store.Ref(errPtr, err); 957 return A.H.FALSE; 958 } 959 }, 960 }; 961 });