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.js
CHANGED
|
@@ -47,7 +47,19 @@ function typeForRpc(value) {
|
|
|
47
47
|
case Array.prototype: return "array";
|
|
48
48
|
case Date.prototype: return "date";
|
|
49
49
|
case Uint8Array.prototype:
|
|
50
|
-
case BUFFER_PROTOTYPE:
|
|
50
|
+
case BUFFER_PROTOTYPE:
|
|
51
|
+
case ArrayBuffer.prototype:
|
|
52
|
+
case DataView.prototype:
|
|
53
|
+
case Int8Array.prototype:
|
|
54
|
+
case Uint8ClampedArray.prototype:
|
|
55
|
+
case Int16Array.prototype:
|
|
56
|
+
case Uint16Array.prototype:
|
|
57
|
+
case Int32Array.prototype:
|
|
58
|
+
case Uint32Array.prototype:
|
|
59
|
+
case BigInt64Array.prototype:
|
|
60
|
+
case BigUint64Array.prototype:
|
|
61
|
+
case Float32Array.prototype:
|
|
62
|
+
case Float64Array.prototype: return "bytes";
|
|
51
63
|
case WritableStream.prototype: return "writable";
|
|
52
64
|
case ReadableStream.prototype: return "readable";
|
|
53
65
|
case Headers.prototype: return "headers";
|
|
@@ -517,6 +529,30 @@ var RpcPayload = class RpcPayload {
|
|
|
517
529
|
this.dispose();
|
|
518
530
|
}
|
|
519
531
|
}
|
|
532
|
+
async deliverStreamWrite(writer) {
|
|
533
|
+
try {
|
|
534
|
+
let promises = [];
|
|
535
|
+
this.deliverTo(this, "value", promises);
|
|
536
|
+
if (promises.length > 0) await Promise.all(promises);
|
|
537
|
+
let chunk = this.value[0];
|
|
538
|
+
if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
|
|
539
|
+
if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
|
|
540
|
+
value: () => this.dispose(),
|
|
541
|
+
writable: true,
|
|
542
|
+
enumerable: false,
|
|
543
|
+
configurable: true
|
|
544
|
+
});
|
|
545
|
+
await writer.write(chunk);
|
|
546
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
547
|
+
}
|
|
548
|
+
await writer.write(chunk);
|
|
549
|
+
this.dispose();
|
|
550
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
551
|
+
} catch (err) {
|
|
552
|
+
this.dispose();
|
|
553
|
+
throw err;
|
|
554
|
+
}
|
|
555
|
+
}
|
|
520
556
|
async deliverResolve() {
|
|
521
557
|
try {
|
|
522
558
|
let promises = [];
|
|
@@ -941,6 +977,71 @@ const DEFAULT_LIMITS = {
|
|
|
941
977
|
maxDepth: 256,
|
|
942
978
|
maxMessageSize: 32 * 1024 * 1024
|
|
943
979
|
};
|
|
980
|
+
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
981
|
+
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
982
|
+
"ArrayBuffer",
|
|
983
|
+
"DataView",
|
|
984
|
+
"Int8Array",
|
|
985
|
+
"Uint8Array",
|
|
986
|
+
"Uint8ClampedArray",
|
|
987
|
+
"Int16Array",
|
|
988
|
+
"Uint16Array",
|
|
989
|
+
"Int32Array",
|
|
990
|
+
"Uint32Array",
|
|
991
|
+
"BigInt64Array",
|
|
992
|
+
"BigUint64Array",
|
|
993
|
+
"Float32Array",
|
|
994
|
+
"Float64Array"
|
|
995
|
+
];
|
|
996
|
+
function isValidByteContainerName(value) {
|
|
997
|
+
return BYTE_CONTAINER_TYPE_NAMES.includes(value);
|
|
998
|
+
}
|
|
999
|
+
const TYPED_ARRAY_ELEMENT_SIZE = {
|
|
1000
|
+
ArrayBuffer: void 0,
|
|
1001
|
+
DataView: void 0,
|
|
1002
|
+
Int8Array: void 0,
|
|
1003
|
+
Uint8Array: void 0,
|
|
1004
|
+
Uint8ClampedArray: void 0,
|
|
1005
|
+
Int16Array: 2,
|
|
1006
|
+
Uint16Array: 2,
|
|
1007
|
+
Int32Array: 4,
|
|
1008
|
+
Uint32Array: 4,
|
|
1009
|
+
BigInt64Array: 8,
|
|
1010
|
+
BigUint64Array: 8,
|
|
1011
|
+
Float32Array: 4,
|
|
1012
|
+
Float64Array: 8
|
|
1013
|
+
};
|
|
1014
|
+
const BYTE_CONTAINER_PROTOTYPES = {
|
|
1015
|
+
ArrayBuffer: ArrayBuffer.prototype,
|
|
1016
|
+
DataView: DataView.prototype,
|
|
1017
|
+
Int8Array: Int8Array.prototype,
|
|
1018
|
+
Uint8ClampedArray: Uint8ClampedArray.prototype,
|
|
1019
|
+
Int16Array: Int16Array.prototype,
|
|
1020
|
+
Uint16Array: Uint16Array.prototype,
|
|
1021
|
+
Int32Array: Int32Array.prototype,
|
|
1022
|
+
Uint32Array: Uint32Array.prototype,
|
|
1023
|
+
BigInt64Array: BigInt64Array.prototype,
|
|
1024
|
+
BigUint64Array: BigUint64Array.prototype,
|
|
1025
|
+
Float32Array: Float32Array.prototype,
|
|
1026
|
+
Float64Array: Float64Array.prototype
|
|
1027
|
+
};
|
|
1028
|
+
const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
|
|
1029
|
+
for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
|
|
1030
|
+
function swapByteOrder(bytes, elementSize) {
|
|
1031
|
+
if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
|
|
1032
|
+
let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
1033
|
+
for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
|
|
1034
|
+
case 2:
|
|
1035
|
+
view.setUint16(offset, view.getUint16(offset, false), true);
|
|
1036
|
+
break;
|
|
1037
|
+
case 4:
|
|
1038
|
+
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1039
|
+
break;
|
|
1040
|
+
case 8:
|
|
1041
|
+
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1042
|
+
break;
|
|
1043
|
+
}
|
|
1044
|
+
}
|
|
944
1045
|
var NullExporter = class {
|
|
945
1046
|
exportStub(stub) {
|
|
946
1047
|
throw new Error("Cannot serialize RPC stubs without an RPC session.");
|
|
@@ -1032,17 +1133,38 @@ var Devaluator = class Devaluator {
|
|
|
1032
1133
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1033
1134
|
}
|
|
1034
1135
|
case "bytes": {
|
|
1035
|
-
let
|
|
1036
|
-
|
|
1037
|
-
if (
|
|
1136
|
+
let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
|
|
1137
|
+
let bytes;
|
|
1138
|
+
if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
|
|
1139
|
+
else if (alternateTypeName === void 0) bytes = value;
|
|
1140
|
+
else {
|
|
1141
|
+
let view = value;
|
|
1142
|
+
bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
|
|
1143
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
|
|
1144
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize) {
|
|
1145
|
+
bytes = bytes.slice();
|
|
1146
|
+
swapByteOrder(bytes, elementSize);
|
|
1147
|
+
}
|
|
1148
|
+
}
|
|
1149
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1150
|
+
"bytes",
|
|
1151
|
+
bytes,
|
|
1152
|
+
alternateTypeName
|
|
1153
|
+
];
|
|
1038
1154
|
let b64;
|
|
1039
|
-
if (
|
|
1155
|
+
if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
|
|
1156
|
+
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
1040
1157
|
else {
|
|
1041
1158
|
let binary = "";
|
|
1042
1159
|
for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
|
|
1043
1160
|
b64 = btoa(binary);
|
|
1044
1161
|
}
|
|
1045
|
-
|
|
1162
|
+
b64 = b64.replace(/=+$/, "");
|
|
1163
|
+
return alternateTypeName === void 0 ? ["bytes", b64] : [
|
|
1164
|
+
"bytes",
|
|
1165
|
+
b64,
|
|
1166
|
+
alternateTypeName
|
|
1167
|
+
];
|
|
1046
1168
|
}
|
|
1047
1169
|
case "headers": return ["headers", [...value]];
|
|
1048
1170
|
case "request": {
|
|
@@ -1295,18 +1417,46 @@ var Evaluator = class Evaluator {
|
|
|
1295
1417
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1296
1418
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1297
1419
|
break;
|
|
1298
|
-
case "bytes":
|
|
1299
|
-
|
|
1300
|
-
if (
|
|
1301
|
-
else if (
|
|
1420
|
+
case "bytes": {
|
|
1421
|
+
let bytes;
|
|
1422
|
+
if (value[1] instanceof Uint8Array) bytes = value[1];
|
|
1423
|
+
else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
|
|
1424
|
+
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1302
1425
|
else {
|
|
1303
1426
|
let bs = atob(value[1]);
|
|
1304
1427
|
let len = bs.length;
|
|
1305
|
-
|
|
1428
|
+
bytes = new Uint8Array(len);
|
|
1306
1429
|
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1307
|
-
return bytes;
|
|
1308
1430
|
}
|
|
1309
|
-
break;
|
|
1431
|
+
else break;
|
|
1432
|
+
if (value.length === 2) return bytes;
|
|
1433
|
+
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1434
|
+
if (!isValidByteContainerName(value[2])) {
|
|
1435
|
+
let marker = value[2].slice(0, 64);
|
|
1436
|
+
throw new TypeError(`Unknown bytes type marker: ${marker}`);
|
|
1437
|
+
}
|
|
1438
|
+
let marker = value[2];
|
|
1439
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
|
|
1440
|
+
if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
|
|
1441
|
+
let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
1442
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
|
|
1443
|
+
switch (marker) {
|
|
1444
|
+
case "ArrayBuffer": return buffer;
|
|
1445
|
+
case "DataView": return new DataView(buffer);
|
|
1446
|
+
case "Int8Array": return new Int8Array(buffer);
|
|
1447
|
+
case "Uint8Array": return new Uint8Array(buffer);
|
|
1448
|
+
case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
|
|
1449
|
+
case "Int16Array": return new Int16Array(buffer);
|
|
1450
|
+
case "Uint16Array": return new Uint16Array(buffer);
|
|
1451
|
+
case "Int32Array": return new Int32Array(buffer);
|
|
1452
|
+
case "Uint32Array": return new Uint32Array(buffer);
|
|
1453
|
+
case "BigInt64Array": return new BigInt64Array(buffer);
|
|
1454
|
+
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1455
|
+
case "Float32Array": return new Float32Array(buffer);
|
|
1456
|
+
case "Float64Array": return new Float64Array(buffer);
|
|
1457
|
+
default:
|
|
1458
|
+
}
|
|
1459
|
+
}
|
|
1310
1460
|
case "error":
|
|
1311
1461
|
if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
|
|
1312
1462
|
let cls = ERROR_TYPES[value[1]] || Error;
|
|
@@ -2251,6 +2401,7 @@ var WebSocketTransport = class {
|
|
|
2251
2401
|
|
|
2252
2402
|
//#endregion
|
|
2253
2403
|
//#region src/batch.ts
|
|
2404
|
+
const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
2254
2405
|
var BatchClientTransport = class {
|
|
2255
2406
|
constructor(sendBatch) {
|
|
2256
2407
|
this.#promise = this.#scheduleBatch(sendBatch);
|
|
@@ -2272,7 +2423,7 @@ var BatchClientTransport = class {
|
|
|
2272
2423
|
this.#aborted = reason;
|
|
2273
2424
|
}
|
|
2274
2425
|
async #scheduleBatch(sendBatch) {
|
|
2275
|
-
await
|
|
2426
|
+
await yieldToMacrotask();
|
|
2276
2427
|
if (this.#aborted !== void 0) throw this.#aborted;
|
|
2277
2428
|
let batch = this.#batchToSend;
|
|
2278
2429
|
this.#batchToSend = null;
|
|
@@ -2682,8 +2833,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2682
2833
|
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2683
2834
|
}
|
|
2684
2835
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2685
|
-
|
|
2686
|
-
return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
|
|
2836
|
+
return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
|
|
2687
2837
|
} catch (err) {
|
|
2688
2838
|
return new ErrorStubHook(err);
|
|
2689
2839
|
}
|