capnweb 0.10.0 → 0.11.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +36 -2
- package/dist/index-bun.cjs +180 -22
- package/dist/index-bun.cjs.map +1 -1
- package/dist/index-bun.d.cts +15 -5
- package/dist/index-bun.d.ts +15 -5
- package/dist/index-bun.js +180 -22
- package/dist/index-bun.js.map +1 -1
- package/dist/index-workers.cjs +180 -22
- package/dist/index-workers.cjs.map +1 -1
- package/dist/index-workers.d.cts +12 -5
- package/dist/index-workers.d.ts +12 -5
- package/dist/index-workers.js +180 -22
- package/dist/index-workers.js.map +1 -1
- package/dist/index.cjs +180 -22
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +12 -5
- package/dist/index.d.ts +12 -5
- package/dist/index.js +180 -22
- package/dist/index.js.map +1 -1
- package/package.json +5 -5
package/dist/index-workers.cjs
CHANGED
|
@@ -76,9 +76,22 @@ function typeForRpc(value) {
|
|
|
76
76
|
case Array.prototype: return "array";
|
|
77
77
|
case Date.prototype: return "date";
|
|
78
78
|
case Uint8Array.prototype:
|
|
79
|
-
case BUFFER_PROTOTYPE:
|
|
79
|
+
case BUFFER_PROTOTYPE:
|
|
80
|
+
case ArrayBuffer.prototype:
|
|
81
|
+
case DataView.prototype:
|
|
82
|
+
case Int8Array.prototype:
|
|
83
|
+
case Uint8ClampedArray.prototype:
|
|
84
|
+
case Int16Array.prototype:
|
|
85
|
+
case Uint16Array.prototype:
|
|
86
|
+
case Int32Array.prototype:
|
|
87
|
+
case Uint32Array.prototype:
|
|
88
|
+
case BigInt64Array.prototype:
|
|
89
|
+
case BigUint64Array.prototype:
|
|
90
|
+
case Float32Array.prototype:
|
|
91
|
+
case Float64Array.prototype: return "bytes";
|
|
80
92
|
case WritableStream.prototype: return "writable";
|
|
81
93
|
case ReadableStream.prototype: return "readable";
|
|
94
|
+
case URL.prototype: return "url";
|
|
82
95
|
case Headers.prototype: return "headers";
|
|
83
96
|
case Request.prototype: return "request";
|
|
84
97
|
case Response.prototype: return "response";
|
|
@@ -413,6 +426,7 @@ var RpcPayload = class RpcPayload {
|
|
|
413
426
|
case "date":
|
|
414
427
|
case "bytes":
|
|
415
428
|
case "blob":
|
|
429
|
+
case "url":
|
|
416
430
|
case "error":
|
|
417
431
|
case "undefined": return value;
|
|
418
432
|
case "array": {
|
|
@@ -546,6 +560,30 @@ var RpcPayload = class RpcPayload {
|
|
|
546
560
|
this.dispose();
|
|
547
561
|
}
|
|
548
562
|
}
|
|
563
|
+
async deliverStreamWrite(writer) {
|
|
564
|
+
try {
|
|
565
|
+
let promises = [];
|
|
566
|
+
this.deliverTo(this, "value", promises);
|
|
567
|
+
if (promises.length > 0) await Promise.all(promises);
|
|
568
|
+
let chunk = this.value[0];
|
|
569
|
+
if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
|
|
570
|
+
if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
|
|
571
|
+
value: () => this.dispose(),
|
|
572
|
+
writable: true,
|
|
573
|
+
enumerable: false,
|
|
574
|
+
configurable: true
|
|
575
|
+
});
|
|
576
|
+
await writer.write(chunk);
|
|
577
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
578
|
+
}
|
|
579
|
+
await writer.write(chunk);
|
|
580
|
+
this.dispose();
|
|
581
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
582
|
+
} catch (err) {
|
|
583
|
+
this.dispose();
|
|
584
|
+
throw err;
|
|
585
|
+
}
|
|
586
|
+
}
|
|
549
587
|
async deliverResolve() {
|
|
550
588
|
try {
|
|
551
589
|
let promises = [];
|
|
@@ -586,6 +624,7 @@ var RpcPayload = class RpcPayload {
|
|
|
586
624
|
case "bytes":
|
|
587
625
|
case "blob":
|
|
588
626
|
case "date":
|
|
627
|
+
case "url":
|
|
589
628
|
case "error":
|
|
590
629
|
case "undefined": return;
|
|
591
630
|
case "array": {
|
|
@@ -668,6 +707,7 @@ var RpcPayload = class RpcPayload {
|
|
|
668
707
|
case "rpc-target":
|
|
669
708
|
case "writable":
|
|
670
709
|
case "readable":
|
|
710
|
+
case "url":
|
|
671
711
|
case "headers":
|
|
672
712
|
case "request":
|
|
673
713
|
case "response": return;
|
|
@@ -737,6 +777,7 @@ function followPath(value, parent, path, owner) {
|
|
|
737
777
|
case "blob":
|
|
738
778
|
case "date":
|
|
739
779
|
case "error":
|
|
780
|
+
case "url":
|
|
740
781
|
case "headers":
|
|
741
782
|
case "request":
|
|
742
783
|
case "response":
|
|
@@ -970,6 +1011,71 @@ const DEFAULT_LIMITS = {
|
|
|
970
1011
|
maxDepth: 256,
|
|
971
1012
|
maxMessageSize: 32 * 1024 * 1024
|
|
972
1013
|
};
|
|
1014
|
+
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
1015
|
+
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
1016
|
+
"ArrayBuffer",
|
|
1017
|
+
"DataView",
|
|
1018
|
+
"Int8Array",
|
|
1019
|
+
"Uint8Array",
|
|
1020
|
+
"Uint8ClampedArray",
|
|
1021
|
+
"Int16Array",
|
|
1022
|
+
"Uint16Array",
|
|
1023
|
+
"Int32Array",
|
|
1024
|
+
"Uint32Array",
|
|
1025
|
+
"BigInt64Array",
|
|
1026
|
+
"BigUint64Array",
|
|
1027
|
+
"Float32Array",
|
|
1028
|
+
"Float64Array"
|
|
1029
|
+
];
|
|
1030
|
+
function isValidByteContainerName(value) {
|
|
1031
|
+
return BYTE_CONTAINER_TYPE_NAMES.includes(value);
|
|
1032
|
+
}
|
|
1033
|
+
const TYPED_ARRAY_ELEMENT_SIZE = {
|
|
1034
|
+
ArrayBuffer: void 0,
|
|
1035
|
+
DataView: void 0,
|
|
1036
|
+
Int8Array: void 0,
|
|
1037
|
+
Uint8Array: void 0,
|
|
1038
|
+
Uint8ClampedArray: void 0,
|
|
1039
|
+
Int16Array: 2,
|
|
1040
|
+
Uint16Array: 2,
|
|
1041
|
+
Int32Array: 4,
|
|
1042
|
+
Uint32Array: 4,
|
|
1043
|
+
BigInt64Array: 8,
|
|
1044
|
+
BigUint64Array: 8,
|
|
1045
|
+
Float32Array: 4,
|
|
1046
|
+
Float64Array: 8
|
|
1047
|
+
};
|
|
1048
|
+
const BYTE_CONTAINER_PROTOTYPES = {
|
|
1049
|
+
ArrayBuffer: ArrayBuffer.prototype,
|
|
1050
|
+
DataView: DataView.prototype,
|
|
1051
|
+
Int8Array: Int8Array.prototype,
|
|
1052
|
+
Uint8ClampedArray: Uint8ClampedArray.prototype,
|
|
1053
|
+
Int16Array: Int16Array.prototype,
|
|
1054
|
+
Uint16Array: Uint16Array.prototype,
|
|
1055
|
+
Int32Array: Int32Array.prototype,
|
|
1056
|
+
Uint32Array: Uint32Array.prototype,
|
|
1057
|
+
BigInt64Array: BigInt64Array.prototype,
|
|
1058
|
+
BigUint64Array: BigUint64Array.prototype,
|
|
1059
|
+
Float32Array: Float32Array.prototype,
|
|
1060
|
+
Float64Array: Float64Array.prototype
|
|
1061
|
+
};
|
|
1062
|
+
const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
|
|
1063
|
+
for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
|
|
1064
|
+
function swapByteOrder(bytes, elementSize) {
|
|
1065
|
+
if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
|
|
1066
|
+
let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
1067
|
+
for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
|
|
1068
|
+
case 2:
|
|
1069
|
+
view.setUint16(offset, view.getUint16(offset, false), true);
|
|
1070
|
+
break;
|
|
1071
|
+
case 4:
|
|
1072
|
+
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1073
|
+
break;
|
|
1074
|
+
case 8:
|
|
1075
|
+
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1076
|
+
break;
|
|
1077
|
+
}
|
|
1078
|
+
}
|
|
973
1079
|
var NullExporter = class {
|
|
974
1080
|
exportStub(stub) {
|
|
975
1081
|
throw new Error("Cannot serialize RPC stubs without an RPC session.");
|
|
@@ -989,7 +1095,8 @@ async function streamToBlob(stream, type) {
|
|
|
989
1095
|
let b = await new Response(stream).blob();
|
|
990
1096
|
return b.type === type ? b : b.slice(0, b.size, type);
|
|
991
1097
|
}
|
|
992
|
-
const ERROR_TYPES =
|
|
1098
|
+
const ERROR_TYPES = {
|
|
1099
|
+
__proto__: null,
|
|
993
1100
|
Error,
|
|
994
1101
|
EvalError,
|
|
995
1102
|
RangeError,
|
|
@@ -998,7 +1105,7 @@ const ERROR_TYPES = Object.assign(Object.create(null), {
|
|
|
998
1105
|
TypeError,
|
|
999
1106
|
URIError,
|
|
1000
1107
|
AggregateError
|
|
1001
|
-
}
|
|
1108
|
+
};
|
|
1002
1109
|
var Devaluator = class Devaluator {
|
|
1003
1110
|
exporter;
|
|
1004
1111
|
source;
|
|
@@ -1060,18 +1167,40 @@ var Devaluator = class Devaluator {
|
|
|
1060
1167
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1061
1168
|
}
|
|
1062
1169
|
case "bytes": {
|
|
1063
|
-
let
|
|
1064
|
-
|
|
1065
|
-
if (
|
|
1170
|
+
let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
|
|
1171
|
+
let bytes;
|
|
1172
|
+
if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
|
|
1173
|
+
else if (alternateTypeName === void 0) bytes = value;
|
|
1174
|
+
else {
|
|
1175
|
+
let view = value;
|
|
1176
|
+
bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
|
|
1177
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
|
|
1178
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize) {
|
|
1179
|
+
bytes = bytes.slice();
|
|
1180
|
+
swapByteOrder(bytes, elementSize);
|
|
1181
|
+
}
|
|
1182
|
+
}
|
|
1183
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1184
|
+
"bytes",
|
|
1185
|
+
bytes,
|
|
1186
|
+
alternateTypeName
|
|
1187
|
+
];
|
|
1066
1188
|
let b64;
|
|
1067
|
-
if (
|
|
1189
|
+
if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
|
|
1190
|
+
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
1068
1191
|
else {
|
|
1069
1192
|
let binary = "";
|
|
1070
1193
|
for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
|
|
1071
1194
|
b64 = btoa(binary);
|
|
1072
1195
|
}
|
|
1073
|
-
|
|
1196
|
+
b64 = b64.replace(/=+$/, "");
|
|
1197
|
+
return alternateTypeName === void 0 ? ["bytes", b64] : [
|
|
1198
|
+
"bytes",
|
|
1199
|
+
b64,
|
|
1200
|
+
alternateTypeName
|
|
1201
|
+
];
|
|
1074
1202
|
}
|
|
1203
|
+
case "url": return ["url", value.href];
|
|
1075
1204
|
case "headers": return ["headers", [...value]];
|
|
1076
1205
|
case "request": {
|
|
1077
1206
|
let req = value;
|
|
@@ -1323,18 +1452,46 @@ var Evaluator = class Evaluator {
|
|
|
1323
1452
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1324
1453
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1325
1454
|
break;
|
|
1326
|
-
case "bytes":
|
|
1327
|
-
|
|
1328
|
-
if (
|
|
1329
|
-
else if (
|
|
1455
|
+
case "bytes": {
|
|
1456
|
+
let bytes;
|
|
1457
|
+
if (value[1] instanceof Uint8Array) bytes = value[1];
|
|
1458
|
+
else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
|
|
1459
|
+
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1330
1460
|
else {
|
|
1331
1461
|
let bs = atob(value[1]);
|
|
1332
1462
|
let len = bs.length;
|
|
1333
|
-
|
|
1463
|
+
bytes = new Uint8Array(len);
|
|
1334
1464
|
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1335
|
-
return bytes;
|
|
1336
1465
|
}
|
|
1337
|
-
break;
|
|
1466
|
+
else break;
|
|
1467
|
+
if (value.length === 2) return bytes;
|
|
1468
|
+
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1469
|
+
if (!isValidByteContainerName(value[2])) {
|
|
1470
|
+
let marker = value[2].slice(0, 64);
|
|
1471
|
+
throw new TypeError(`Unknown bytes type marker: ${marker}`);
|
|
1472
|
+
}
|
|
1473
|
+
let marker = value[2];
|
|
1474
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
|
|
1475
|
+
if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
|
|
1476
|
+
let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
1477
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
|
|
1478
|
+
switch (marker) {
|
|
1479
|
+
case "ArrayBuffer": return buffer;
|
|
1480
|
+
case "DataView": return new DataView(buffer);
|
|
1481
|
+
case "Int8Array": return new Int8Array(buffer);
|
|
1482
|
+
case "Uint8Array": return new Uint8Array(buffer);
|
|
1483
|
+
case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
|
|
1484
|
+
case "Int16Array": return new Int16Array(buffer);
|
|
1485
|
+
case "Uint16Array": return new Uint16Array(buffer);
|
|
1486
|
+
case "Int32Array": return new Int32Array(buffer);
|
|
1487
|
+
case "Uint32Array": return new Uint32Array(buffer);
|
|
1488
|
+
case "BigInt64Array": return new BigInt64Array(buffer);
|
|
1489
|
+
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1490
|
+
case "Float32Array": return new Float32Array(buffer);
|
|
1491
|
+
case "Float64Array": return new Float64Array(buffer);
|
|
1492
|
+
default:
|
|
1493
|
+
}
|
|
1494
|
+
}
|
|
1338
1495
|
case "error":
|
|
1339
1496
|
if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
|
|
1340
1497
|
let cls = ERROR_TYPES[value[1]] || Error;
|
|
@@ -1363,6 +1520,9 @@ var Evaluator = class Evaluator {
|
|
|
1363
1520
|
case "inf": return Infinity;
|
|
1364
1521
|
case "-inf": return -Infinity;
|
|
1365
1522
|
case "nan": return NaN;
|
|
1523
|
+
case "url":
|
|
1524
|
+
if (value.length === 2 && typeof value[1] === "string") return new URL(value[1]);
|
|
1525
|
+
break;
|
|
1366
1526
|
case "headers":
|
|
1367
1527
|
if (value.length === 2 && value[1] instanceof Array) return new Headers(value[1]);
|
|
1368
1528
|
break;
|
|
@@ -1584,10 +1744,6 @@ var ImportTableEntry = class {
|
|
|
1584
1744
|
resolution;
|
|
1585
1745
|
onBrokenRegistrations;
|
|
1586
1746
|
resolve(resolution) {
|
|
1587
|
-
if (this.resolution) {
|
|
1588
|
-
resolution.dispose();
|
|
1589
|
-
return;
|
|
1590
|
-
}
|
|
1591
1747
|
if (this.localRefcount == 0) {
|
|
1592
1748
|
resolution.dispose();
|
|
1593
1749
|
return;
|
|
@@ -2187,6 +2343,8 @@ var RpcSession$1 = class {
|
|
|
2187
2343
|
|
|
2188
2344
|
//#endregion
|
|
2189
2345
|
//#region src/websocket.ts
|
|
2346
|
+
/** Close-frame reason max UTF-8 bytes: 125 payload - 2-byte status (RFC 6455 section 5.5). */
|
|
2347
|
+
const MAX_CLOSE_REASON_BYTES = 123;
|
|
2190
2348
|
function newWebSocketRpcSession$1(webSocket, localMain, options) {
|
|
2191
2349
|
if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
|
|
2192
2350
|
return new RpcSession$1(new WebSocketTransport(webSocket), localMain, options).getRemoteMain();
|
|
@@ -2281,6 +2439,7 @@ var WebSocketTransport = class {
|
|
|
2281
2439
|
|
|
2282
2440
|
//#endregion
|
|
2283
2441
|
//#region src/batch.ts
|
|
2442
|
+
const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
2284
2443
|
var BatchClientTransport = class {
|
|
2285
2444
|
constructor(sendBatch) {
|
|
2286
2445
|
this.#promise = this.#scheduleBatch(sendBatch);
|
|
@@ -2302,7 +2461,7 @@ var BatchClientTransport = class {
|
|
|
2302
2461
|
this.#aborted = reason;
|
|
2303
2462
|
}
|
|
2304
2463
|
async #scheduleBatch(sendBatch) {
|
|
2305
|
-
await
|
|
2464
|
+
await yieldToMacrotask();
|
|
2306
2465
|
if (this.#aborted !== void 0) throw this.#aborted;
|
|
2307
2466
|
let batch = this.#batchToSend;
|
|
2308
2467
|
this.#batchToSend = null;
|
|
@@ -2712,8 +2871,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2712
2871
|
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2713
2872
|
}
|
|
2714
2873
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2715
|
-
|
|
2716
|
-
return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
|
|
2874
|
+
return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
|
|
2717
2875
|
} catch (err) {
|
|
2718
2876
|
return new ErrorStubHook(err);
|
|
2719
2877
|
}
|