capnweb 0.0.0-2a02db9 → 0.0.0-2b292e4
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 +35 -2
- package/dist/index-bun.cjs +166 -16
- package/dist/index-bun.cjs.map +1 -1
- package/dist/index-bun.d.cts +3 -0
- package/dist/index-bun.d.ts +3 -0
- package/dist/index-bun.js +166 -16
- package/dist/index-bun.js.map +1 -1
- package/dist/index-workers.cjs +166 -16
- package/dist/index-workers.cjs.map +1 -1
- package/dist/index-workers.js +166 -16
- package/dist/index-workers.js.map +1 -1
- package/dist/index.cjs +166 -16
- package/dist/index.cjs.map +1 -1
- package/dist/index.js +166 -16
- package/dist/index.js.map +1 -1
- package/package.json +4 -4
package/dist/index-workers.cjs
CHANGED
|
@@ -76,7 +76,19 @@ 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";
|
|
82
94
|
case Headers.prototype: return "headers";
|
|
@@ -546,6 +558,30 @@ var RpcPayload = class RpcPayload {
|
|
|
546
558
|
this.dispose();
|
|
547
559
|
}
|
|
548
560
|
}
|
|
561
|
+
async deliverStreamWrite(writer) {
|
|
562
|
+
try {
|
|
563
|
+
let promises = [];
|
|
564
|
+
this.deliverTo(this, "value", promises);
|
|
565
|
+
if (promises.length > 0) await Promise.all(promises);
|
|
566
|
+
let chunk = this.value[0];
|
|
567
|
+
if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
|
|
568
|
+
if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
|
|
569
|
+
value: () => this.dispose(),
|
|
570
|
+
writable: true,
|
|
571
|
+
enumerable: false,
|
|
572
|
+
configurable: true
|
|
573
|
+
});
|
|
574
|
+
await writer.write(chunk);
|
|
575
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
576
|
+
}
|
|
577
|
+
await writer.write(chunk);
|
|
578
|
+
this.dispose();
|
|
579
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
580
|
+
} catch (err) {
|
|
581
|
+
this.dispose();
|
|
582
|
+
throw err;
|
|
583
|
+
}
|
|
584
|
+
}
|
|
549
585
|
async deliverResolve() {
|
|
550
586
|
try {
|
|
551
587
|
let promises = [];
|
|
@@ -970,6 +1006,71 @@ const DEFAULT_LIMITS = {
|
|
|
970
1006
|
maxDepth: 256,
|
|
971
1007
|
maxMessageSize: 32 * 1024 * 1024
|
|
972
1008
|
};
|
|
1009
|
+
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
1010
|
+
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
1011
|
+
"ArrayBuffer",
|
|
1012
|
+
"DataView",
|
|
1013
|
+
"Int8Array",
|
|
1014
|
+
"Uint8Array",
|
|
1015
|
+
"Uint8ClampedArray",
|
|
1016
|
+
"Int16Array",
|
|
1017
|
+
"Uint16Array",
|
|
1018
|
+
"Int32Array",
|
|
1019
|
+
"Uint32Array",
|
|
1020
|
+
"BigInt64Array",
|
|
1021
|
+
"BigUint64Array",
|
|
1022
|
+
"Float32Array",
|
|
1023
|
+
"Float64Array"
|
|
1024
|
+
];
|
|
1025
|
+
function isValidByteContainerName(value) {
|
|
1026
|
+
return BYTE_CONTAINER_TYPE_NAMES.includes(value);
|
|
1027
|
+
}
|
|
1028
|
+
const TYPED_ARRAY_ELEMENT_SIZE = {
|
|
1029
|
+
ArrayBuffer: void 0,
|
|
1030
|
+
DataView: void 0,
|
|
1031
|
+
Int8Array: void 0,
|
|
1032
|
+
Uint8Array: void 0,
|
|
1033
|
+
Uint8ClampedArray: void 0,
|
|
1034
|
+
Int16Array: 2,
|
|
1035
|
+
Uint16Array: 2,
|
|
1036
|
+
Int32Array: 4,
|
|
1037
|
+
Uint32Array: 4,
|
|
1038
|
+
BigInt64Array: 8,
|
|
1039
|
+
BigUint64Array: 8,
|
|
1040
|
+
Float32Array: 4,
|
|
1041
|
+
Float64Array: 8
|
|
1042
|
+
};
|
|
1043
|
+
const BYTE_CONTAINER_PROTOTYPES = {
|
|
1044
|
+
ArrayBuffer: ArrayBuffer.prototype,
|
|
1045
|
+
DataView: DataView.prototype,
|
|
1046
|
+
Int8Array: Int8Array.prototype,
|
|
1047
|
+
Uint8ClampedArray: Uint8ClampedArray.prototype,
|
|
1048
|
+
Int16Array: Int16Array.prototype,
|
|
1049
|
+
Uint16Array: Uint16Array.prototype,
|
|
1050
|
+
Int32Array: Int32Array.prototype,
|
|
1051
|
+
Uint32Array: Uint32Array.prototype,
|
|
1052
|
+
BigInt64Array: BigInt64Array.prototype,
|
|
1053
|
+
BigUint64Array: BigUint64Array.prototype,
|
|
1054
|
+
Float32Array: Float32Array.prototype,
|
|
1055
|
+
Float64Array: Float64Array.prototype
|
|
1056
|
+
};
|
|
1057
|
+
const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
|
|
1058
|
+
for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
|
|
1059
|
+
function swapByteOrder(bytes, elementSize) {
|
|
1060
|
+
if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
|
|
1061
|
+
let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
1062
|
+
for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
|
|
1063
|
+
case 2:
|
|
1064
|
+
view.setUint16(offset, view.getUint16(offset, false), true);
|
|
1065
|
+
break;
|
|
1066
|
+
case 4:
|
|
1067
|
+
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1068
|
+
break;
|
|
1069
|
+
case 8:
|
|
1070
|
+
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1071
|
+
break;
|
|
1072
|
+
}
|
|
1073
|
+
}
|
|
973
1074
|
var NullExporter = class {
|
|
974
1075
|
exportStub(stub) {
|
|
975
1076
|
throw new Error("Cannot serialize RPC stubs without an RPC session.");
|
|
@@ -1061,17 +1162,38 @@ var Devaluator = class Devaluator {
|
|
|
1061
1162
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1062
1163
|
}
|
|
1063
1164
|
case "bytes": {
|
|
1064
|
-
let
|
|
1065
|
-
|
|
1066
|
-
if (
|
|
1165
|
+
let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
|
|
1166
|
+
let bytes;
|
|
1167
|
+
if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
|
|
1168
|
+
else if (alternateTypeName === void 0) bytes = value;
|
|
1169
|
+
else {
|
|
1170
|
+
let view = value;
|
|
1171
|
+
bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
|
|
1172
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
|
|
1173
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize) {
|
|
1174
|
+
bytes = bytes.slice();
|
|
1175
|
+
swapByteOrder(bytes, elementSize);
|
|
1176
|
+
}
|
|
1177
|
+
}
|
|
1178
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1179
|
+
"bytes",
|
|
1180
|
+
bytes,
|
|
1181
|
+
alternateTypeName
|
|
1182
|
+
];
|
|
1067
1183
|
let b64;
|
|
1068
|
-
if (
|
|
1184
|
+
if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
|
|
1185
|
+
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
1069
1186
|
else {
|
|
1070
1187
|
let binary = "";
|
|
1071
1188
|
for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
|
|
1072
1189
|
b64 = btoa(binary);
|
|
1073
1190
|
}
|
|
1074
|
-
|
|
1191
|
+
b64 = b64.replace(/=+$/, "");
|
|
1192
|
+
return alternateTypeName === void 0 ? ["bytes", b64] : [
|
|
1193
|
+
"bytes",
|
|
1194
|
+
b64,
|
|
1195
|
+
alternateTypeName
|
|
1196
|
+
];
|
|
1075
1197
|
}
|
|
1076
1198
|
case "headers": return ["headers", [...value]];
|
|
1077
1199
|
case "request": {
|
|
@@ -1324,18 +1446,46 @@ var Evaluator = class Evaluator {
|
|
|
1324
1446
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1325
1447
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1326
1448
|
break;
|
|
1327
|
-
case "bytes":
|
|
1328
|
-
|
|
1329
|
-
if (
|
|
1330
|
-
else if (
|
|
1449
|
+
case "bytes": {
|
|
1450
|
+
let bytes;
|
|
1451
|
+
if (value[1] instanceof Uint8Array) bytes = value[1];
|
|
1452
|
+
else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
|
|
1453
|
+
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1331
1454
|
else {
|
|
1332
1455
|
let bs = atob(value[1]);
|
|
1333
1456
|
let len = bs.length;
|
|
1334
|
-
|
|
1457
|
+
bytes = new Uint8Array(len);
|
|
1335
1458
|
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1336
|
-
return bytes;
|
|
1337
1459
|
}
|
|
1338
|
-
break;
|
|
1460
|
+
else break;
|
|
1461
|
+
if (value.length === 2) return bytes;
|
|
1462
|
+
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1463
|
+
if (!isValidByteContainerName(value[2])) {
|
|
1464
|
+
let marker = value[2].slice(0, 64);
|
|
1465
|
+
throw new TypeError(`Unknown bytes type marker: ${marker}`);
|
|
1466
|
+
}
|
|
1467
|
+
let marker = value[2];
|
|
1468
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
|
|
1469
|
+
if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
|
|
1470
|
+
let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
1471
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
|
|
1472
|
+
switch (marker) {
|
|
1473
|
+
case "ArrayBuffer": return buffer;
|
|
1474
|
+
case "DataView": return new DataView(buffer);
|
|
1475
|
+
case "Int8Array": return new Int8Array(buffer);
|
|
1476
|
+
case "Uint8Array": return new Uint8Array(buffer);
|
|
1477
|
+
case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
|
|
1478
|
+
case "Int16Array": return new Int16Array(buffer);
|
|
1479
|
+
case "Uint16Array": return new Uint16Array(buffer);
|
|
1480
|
+
case "Int32Array": return new Int32Array(buffer);
|
|
1481
|
+
case "Uint32Array": return new Uint32Array(buffer);
|
|
1482
|
+
case "BigInt64Array": return new BigInt64Array(buffer);
|
|
1483
|
+
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1484
|
+
case "Float32Array": return new Float32Array(buffer);
|
|
1485
|
+
case "Float64Array": return new Float64Array(buffer);
|
|
1486
|
+
default:
|
|
1487
|
+
}
|
|
1488
|
+
}
|
|
1339
1489
|
case "error":
|
|
1340
1490
|
if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
|
|
1341
1491
|
let cls = ERROR_TYPES[value[1]] || Error;
|
|
@@ -2280,6 +2430,7 @@ var WebSocketTransport = class {
|
|
|
2280
2430
|
|
|
2281
2431
|
//#endregion
|
|
2282
2432
|
//#region src/batch.ts
|
|
2433
|
+
const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
2283
2434
|
var BatchClientTransport = class {
|
|
2284
2435
|
constructor(sendBatch) {
|
|
2285
2436
|
this.#promise = this.#scheduleBatch(sendBatch);
|
|
@@ -2301,7 +2452,7 @@ var BatchClientTransport = class {
|
|
|
2301
2452
|
this.#aborted = reason;
|
|
2302
2453
|
}
|
|
2303
2454
|
async #scheduleBatch(sendBatch) {
|
|
2304
|
-
await
|
|
2455
|
+
await yieldToMacrotask();
|
|
2305
2456
|
if (this.#aborted !== void 0) throw this.#aborted;
|
|
2306
2457
|
let batch = this.#batchToSend;
|
|
2307
2458
|
this.#batchToSend = null;
|
|
@@ -2711,8 +2862,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2711
2862
|
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2712
2863
|
}
|
|
2713
2864
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2714
|
-
|
|
2715
|
-
return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
|
|
2865
|
+
return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
|
|
2716
2866
|
} catch (err) {
|
|
2717
2867
|
return new ErrorStubHook(err);
|
|
2718
2868
|
}
|