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-bun.d.cts
CHANGED
|
@@ -172,6 +172,9 @@ declare class RpcPayload {
|
|
|
172
172
|
private deliverTo;
|
|
173
173
|
private static deliverRpcPromiseTo;
|
|
174
174
|
deliverCall(func: Function, thisArg: object | undefined): Promise<RpcPayload>;
|
|
175
|
+
deliverStreamWrite(writer: {
|
|
176
|
+
write(chunk: unknown): Promise<void>;
|
|
177
|
+
}): Promise<RpcPayload>;
|
|
175
178
|
deliverResolve(): Promise<unknown>;
|
|
176
179
|
dispose(): void;
|
|
177
180
|
private disposeImpl;
|
package/dist/index-bun.d.ts
CHANGED
|
@@ -172,6 +172,9 @@ declare class RpcPayload {
|
|
|
172
172
|
private deliverTo;
|
|
173
173
|
private static deliverRpcPromiseTo;
|
|
174
174
|
deliverCall(func: Function, thisArg: object | undefined): Promise<RpcPayload>;
|
|
175
|
+
deliverStreamWrite(writer: {
|
|
176
|
+
write(chunk: unknown): Promise<void>;
|
|
177
|
+
}): Promise<RpcPayload>;
|
|
175
178
|
deliverResolve(): Promise<unknown>;
|
|
176
179
|
dispose(): void;
|
|
177
180
|
private disposeImpl;
|
package/dist/index-bun.js
CHANGED
|
@@ -41,7 +41,19 @@ function typeForRpc(value) {
|
|
|
41
41
|
case Array.prototype: return "array";
|
|
42
42
|
case Date.prototype: return "date";
|
|
43
43
|
case Uint8Array.prototype:
|
|
44
|
-
case BUFFER_PROTOTYPE:
|
|
44
|
+
case BUFFER_PROTOTYPE:
|
|
45
|
+
case ArrayBuffer.prototype:
|
|
46
|
+
case DataView.prototype:
|
|
47
|
+
case Int8Array.prototype:
|
|
48
|
+
case Uint8ClampedArray.prototype:
|
|
49
|
+
case Int16Array.prototype:
|
|
50
|
+
case Uint16Array.prototype:
|
|
51
|
+
case Int32Array.prototype:
|
|
52
|
+
case Uint32Array.prototype:
|
|
53
|
+
case BigInt64Array.prototype:
|
|
54
|
+
case BigUint64Array.prototype:
|
|
55
|
+
case Float32Array.prototype:
|
|
56
|
+
case Float64Array.prototype: return "bytes";
|
|
45
57
|
case WritableStream.prototype: return "writable";
|
|
46
58
|
case ReadableStream.prototype: return "readable";
|
|
47
59
|
case Headers.prototype: return "headers";
|
|
@@ -511,6 +523,30 @@ var RpcPayload = class RpcPayload {
|
|
|
511
523
|
this.dispose();
|
|
512
524
|
}
|
|
513
525
|
}
|
|
526
|
+
async deliverStreamWrite(writer) {
|
|
527
|
+
try {
|
|
528
|
+
let promises = [];
|
|
529
|
+
this.deliverTo(this, "value", promises);
|
|
530
|
+
if (promises.length > 0) await Promise.all(promises);
|
|
531
|
+
let chunk = this.value[0];
|
|
532
|
+
if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
|
|
533
|
+
if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
|
|
534
|
+
value: () => this.dispose(),
|
|
535
|
+
writable: true,
|
|
536
|
+
enumerable: false,
|
|
537
|
+
configurable: true
|
|
538
|
+
});
|
|
539
|
+
await writer.write(chunk);
|
|
540
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
541
|
+
}
|
|
542
|
+
await writer.write(chunk);
|
|
543
|
+
this.dispose();
|
|
544
|
+
return RpcPayload.fromAppReturn(void 0);
|
|
545
|
+
} catch (err) {
|
|
546
|
+
this.dispose();
|
|
547
|
+
throw err;
|
|
548
|
+
}
|
|
549
|
+
}
|
|
514
550
|
async deliverResolve() {
|
|
515
551
|
try {
|
|
516
552
|
let promises = [];
|
|
@@ -935,6 +971,71 @@ const DEFAULT_LIMITS = {
|
|
|
935
971
|
maxDepth: 256,
|
|
936
972
|
maxMessageSize: 32 * 1024 * 1024
|
|
937
973
|
};
|
|
974
|
+
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
975
|
+
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
976
|
+
"ArrayBuffer",
|
|
977
|
+
"DataView",
|
|
978
|
+
"Int8Array",
|
|
979
|
+
"Uint8Array",
|
|
980
|
+
"Uint8ClampedArray",
|
|
981
|
+
"Int16Array",
|
|
982
|
+
"Uint16Array",
|
|
983
|
+
"Int32Array",
|
|
984
|
+
"Uint32Array",
|
|
985
|
+
"BigInt64Array",
|
|
986
|
+
"BigUint64Array",
|
|
987
|
+
"Float32Array",
|
|
988
|
+
"Float64Array"
|
|
989
|
+
];
|
|
990
|
+
function isValidByteContainerName(value) {
|
|
991
|
+
return BYTE_CONTAINER_TYPE_NAMES.includes(value);
|
|
992
|
+
}
|
|
993
|
+
const TYPED_ARRAY_ELEMENT_SIZE = {
|
|
994
|
+
ArrayBuffer: void 0,
|
|
995
|
+
DataView: void 0,
|
|
996
|
+
Int8Array: void 0,
|
|
997
|
+
Uint8Array: void 0,
|
|
998
|
+
Uint8ClampedArray: void 0,
|
|
999
|
+
Int16Array: 2,
|
|
1000
|
+
Uint16Array: 2,
|
|
1001
|
+
Int32Array: 4,
|
|
1002
|
+
Uint32Array: 4,
|
|
1003
|
+
BigInt64Array: 8,
|
|
1004
|
+
BigUint64Array: 8,
|
|
1005
|
+
Float32Array: 4,
|
|
1006
|
+
Float64Array: 8
|
|
1007
|
+
};
|
|
1008
|
+
const BYTE_CONTAINER_PROTOTYPES = {
|
|
1009
|
+
ArrayBuffer: ArrayBuffer.prototype,
|
|
1010
|
+
DataView: DataView.prototype,
|
|
1011
|
+
Int8Array: Int8Array.prototype,
|
|
1012
|
+
Uint8ClampedArray: Uint8ClampedArray.prototype,
|
|
1013
|
+
Int16Array: Int16Array.prototype,
|
|
1014
|
+
Uint16Array: Uint16Array.prototype,
|
|
1015
|
+
Int32Array: Int32Array.prototype,
|
|
1016
|
+
Uint32Array: Uint32Array.prototype,
|
|
1017
|
+
BigInt64Array: BigInt64Array.prototype,
|
|
1018
|
+
BigUint64Array: BigUint64Array.prototype,
|
|
1019
|
+
Float32Array: Float32Array.prototype,
|
|
1020
|
+
Float64Array: Float64Array.prototype
|
|
1021
|
+
};
|
|
1022
|
+
const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
|
|
1023
|
+
for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
|
|
1024
|
+
function swapByteOrder(bytes, elementSize) {
|
|
1025
|
+
if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
|
|
1026
|
+
let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
1027
|
+
for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
|
|
1028
|
+
case 2:
|
|
1029
|
+
view.setUint16(offset, view.getUint16(offset, false), true);
|
|
1030
|
+
break;
|
|
1031
|
+
case 4:
|
|
1032
|
+
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1033
|
+
break;
|
|
1034
|
+
case 8:
|
|
1035
|
+
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1036
|
+
break;
|
|
1037
|
+
}
|
|
1038
|
+
}
|
|
938
1039
|
var NullExporter = class {
|
|
939
1040
|
exportStub(stub) {
|
|
940
1041
|
throw new Error("Cannot serialize RPC stubs without an RPC session.");
|
|
@@ -1026,17 +1127,38 @@ var Devaluator = class Devaluator {
|
|
|
1026
1127
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1027
1128
|
}
|
|
1028
1129
|
case "bytes": {
|
|
1029
|
-
let
|
|
1030
|
-
|
|
1031
|
-
if (
|
|
1130
|
+
let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
|
|
1131
|
+
let bytes;
|
|
1132
|
+
if (alternateTypeName === "ArrayBuffer") bytes = new Uint8Array(value);
|
|
1133
|
+
else if (alternateTypeName === void 0) bytes = value;
|
|
1134
|
+
else {
|
|
1135
|
+
let view = value;
|
|
1136
|
+
bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
|
|
1137
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
|
|
1138
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize) {
|
|
1139
|
+
bytes = bytes.slice();
|
|
1140
|
+
swapByteOrder(bytes, elementSize);
|
|
1141
|
+
}
|
|
1142
|
+
}
|
|
1143
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1144
|
+
"bytes",
|
|
1145
|
+
bytes,
|
|
1146
|
+
alternateTypeName
|
|
1147
|
+
];
|
|
1032
1148
|
let b64;
|
|
1033
|
-
if (
|
|
1149
|
+
if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
|
|
1150
|
+
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
1034
1151
|
else {
|
|
1035
1152
|
let binary = "";
|
|
1036
1153
|
for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
|
|
1037
1154
|
b64 = btoa(binary);
|
|
1038
1155
|
}
|
|
1039
|
-
|
|
1156
|
+
b64 = b64.replace(/=+$/, "");
|
|
1157
|
+
return alternateTypeName === void 0 ? ["bytes", b64] : [
|
|
1158
|
+
"bytes",
|
|
1159
|
+
b64,
|
|
1160
|
+
alternateTypeName
|
|
1161
|
+
];
|
|
1040
1162
|
}
|
|
1041
1163
|
case "headers": return ["headers", [...value]];
|
|
1042
1164
|
case "request": {
|
|
@@ -1289,18 +1411,46 @@ var Evaluator = class Evaluator {
|
|
|
1289
1411
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1290
1412
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1291
1413
|
break;
|
|
1292
|
-
case "bytes":
|
|
1293
|
-
|
|
1294
|
-
if (
|
|
1295
|
-
else if (
|
|
1414
|
+
case "bytes": {
|
|
1415
|
+
let bytes;
|
|
1416
|
+
if (value[1] instanceof Uint8Array) bytes = value[1];
|
|
1417
|
+
else if (typeof value[1] == "string") if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
|
|
1418
|
+
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1296
1419
|
else {
|
|
1297
1420
|
let bs = atob(value[1]);
|
|
1298
1421
|
let len = bs.length;
|
|
1299
|
-
|
|
1422
|
+
bytes = new Uint8Array(len);
|
|
1300
1423
|
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1301
|
-
return bytes;
|
|
1302
1424
|
}
|
|
1303
|
-
break;
|
|
1425
|
+
else break;
|
|
1426
|
+
if (value.length === 2) return bytes;
|
|
1427
|
+
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1428
|
+
if (!isValidByteContainerName(value[2])) {
|
|
1429
|
+
let marker = value[2].slice(0, 64);
|
|
1430
|
+
throw new TypeError(`Unknown bytes type marker: ${marker}`);
|
|
1431
|
+
}
|
|
1432
|
+
let marker = value[2];
|
|
1433
|
+
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
|
|
1434
|
+
if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
|
|
1435
|
+
let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
1436
|
+
if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
|
|
1437
|
+
switch (marker) {
|
|
1438
|
+
case "ArrayBuffer": return buffer;
|
|
1439
|
+
case "DataView": return new DataView(buffer);
|
|
1440
|
+
case "Int8Array": return new Int8Array(buffer);
|
|
1441
|
+
case "Uint8Array": return new Uint8Array(buffer);
|
|
1442
|
+
case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
|
|
1443
|
+
case "Int16Array": return new Int16Array(buffer);
|
|
1444
|
+
case "Uint16Array": return new Uint16Array(buffer);
|
|
1445
|
+
case "Int32Array": return new Int32Array(buffer);
|
|
1446
|
+
case "Uint32Array": return new Uint32Array(buffer);
|
|
1447
|
+
case "BigInt64Array": return new BigInt64Array(buffer);
|
|
1448
|
+
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1449
|
+
case "Float32Array": return new Float32Array(buffer);
|
|
1450
|
+
case "Float64Array": return new Float64Array(buffer);
|
|
1451
|
+
default:
|
|
1452
|
+
}
|
|
1453
|
+
}
|
|
1304
1454
|
case "error":
|
|
1305
1455
|
if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
|
|
1306
1456
|
let cls = ERROR_TYPES[value[1]] || Error;
|
|
@@ -2245,6 +2395,7 @@ var WebSocketTransport = class {
|
|
|
2245
2395
|
|
|
2246
2396
|
//#endregion
|
|
2247
2397
|
//#region src/batch.ts
|
|
2398
|
+
const yieldToMacrotask = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
2248
2399
|
var BatchClientTransport = class {
|
|
2249
2400
|
constructor(sendBatch) {
|
|
2250
2401
|
this.#promise = this.#scheduleBatch(sendBatch);
|
|
@@ -2266,7 +2417,7 @@ var BatchClientTransport = class {
|
|
|
2266
2417
|
this.#aborted = reason;
|
|
2267
2418
|
}
|
|
2268
2419
|
async #scheduleBatch(sendBatch) {
|
|
2269
|
-
await
|
|
2420
|
+
await yieldToMacrotask();
|
|
2270
2421
|
if (this.#aborted !== void 0) throw this.#aborted;
|
|
2271
2422
|
let batch = this.#batchToSend;
|
|
2272
2423
|
this.#batchToSend = null;
|
|
@@ -2676,8 +2827,7 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2676
2827
|
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2677
2828
|
}
|
|
2678
2829
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2679
|
-
|
|
2680
|
-
return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
|
|
2830
|
+
return new PromiseStubHook((method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer)).then((payload) => new PayloadStubHook(payload)));
|
|
2681
2831
|
} catch (err) {
|
|
2682
2832
|
return new ErrorStubHook(err);
|
|
2683
2833
|
}
|