typeson-registry 14.1.0 → 14.2.0

package/dist/polyfills/SyncBlobFile.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A `Blob` subclass which also keeps a synchronously-readable copy of its
+ *   content (accessible only via `getSyncBytes`, not as a property of the
+ *   instance itself), for environments (e.g. Node without jsdom) where
+ *   `Blob` alone offers no synchronous way to read it back.
+ */
+export class SyncBlob extends Blob {
+    /**
+     * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} [parts]
+     * @param {BlobPropertyBag} [options]
+     */
+    constructor(parts?: (string | ArrayBuffer | ArrayBufferView | Blob)[], options?: BlobPropertyBag);
+}
+/**
+ * `File` counterpart to `SyncBlob` -- see its documentation for why this
+ *   exists.
+ */
+export class SyncFile extends File {
+    /**
+     * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} parts
+     * @param {string} name
+     * @param {FilePropertyBag} [options]
+     */
+    constructor(parts: (string | ArrayBuffer | ArrayBufferView | Blob)[], name: string, options?: FilePropertyBag);
+}
+/**
+ * @param {Blob} blob A `SyncBlob`/`SyncFile` (or any `Blob`/`File` this
+ *   module has otherwise recorded bytes for).
+ * @returns {Buffer|undefined} `undefined` if `blob` isn't one this module
+ *   has a synchronous copy for.
+ */
+export function getSyncBytes(blob: Blob): Buffer | undefined;
+//# sourceMappingURL=SyncBlobFile.d.ts.map

package/dist/polyfills/SyncBlobFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncBlobFile.d.ts","sourceRoot":"","sources":["../../polyfills/SyncBlobFile.js"],"names":[],"mappings":"AA6DA;;;;;GAKG;AACH;IACI;;;OAGG;IAGH,oBALW,CAAC,MAAM,GAAC,WAAW,GAAC,eAAe,GAAC,IAAI,CAAC,EAAE,YAC3C,eAAe,EAOzB;CACJ;AAED;;;GAGG;AACH;IACI;;;;OAIG;IACH,mBAJW,CAAC,MAAM,GAAC,WAAW,GAAC,eAAe,GAAC,IAAI,CAAC,EAAE,QAC3C,MAAM,YACN,eAAe,EAKzB;CACJ;AApED;;;;;GAKG;AACH,mCALW,IAAI,GAEF,MAAM,GAAC,SAAS,CAK5B"}

package/dist/polyfills/URL.d.ts

@@ -22,4 +22,27 @@ export function xmlHttpRequestOverrideMimeType({ polyfillDataURLs }?: {
  * @returns {void}
  */
 export function revokeObjectURL(blobURL: string): void;
+/**
+ * Resolves a `blob:` URL (previously registered via `createObjectURL`) back
+ *   to its content, synchronously -- for use by any XHR/`fetch` polyfill
+ *   that needs to serve `blob:` URLs itself (mirroring how browsers read
+ *   `blob:` URLs without going over the network).
+ * @param {string} blobURL
+ * @returns {{type: string, bytes: Buffer}|undefined} `undefined` if
+ *   `blobURL` is not (or is no longer) a registered `blob:` URL.
+ */
+export function resolveObjectURL(blobURL: string): {
+    type: string;
+    bytes: Buffer;
+} | undefined;
+/**
+ * Synchronously reads the content of a `Blob`/`File` previously registered
+ *   via `createObjectURL`. `SyncBlob`/`SyncFile` (see `SyncBlobFile.js`)
+ *   keep their own synchronously-readable copy of the content for
+ *   environments without jsdom (e.g. Node on its own); prefer that if
+ *   present, falling back to jsdom's internal wrapper-unwrapping otherwise.
+ * @param {Blob} blob
+ * @returns {Buffer|undefined}
+ */
+export function getBlobBytesSync(blob: Blob): Buffer | undefined;
 //# sourceMappingURL=URL.d.ts.map

package/dist/polyfills/URL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"URL.d.ts","sourceRoot":"","sources":["../../polyfills/URL.js"],"names":[],"mappings":"qDA4DW,MAAM,KACJ,IAAI;AAlCjB;;;GAGG;AACH,sCAHW,IAAI,GACF,MAAM,CAgBlB;AAaD;;;;GAIG;AAEH;;;;GAIG;AACH,sEAHG;IAAsB,gBAAgB;CACtC,GAAU,2BAA2B,CAkEvC;AAtFD;;;GAGG;AACH,yCAHW,MAAM,GACJ,IAAI,CAIhB"}
+{"version":3,"file":"URL.d.ts","sourceRoot":"","sources":["../../polyfills/URL.js"],"names":[],"mappings":"qDAgGW,MAAM,KACJ,IAAI;AArEjB;;;GAGG;AACH,sCAHW,IAAI,GACF,MAAM,CAgBlB;AAgDD;;;;GAIG;AAEH;;;;GAIG;AACH,sEAHG;IAAsB,gBAAgB;CACtC,GAAU,2BAA2B,CAoEvC;AA3HD;;;GAGG;AACH,yCAHW,MAAM,GACJ,IAAI,CAIhB;AAeD;;;;;;;;GAQG;AACH,0CAJW,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GAAC,SAAS,CAcnD;AAjCD;;;;;;;;GAQG;AACH,uCAHW,IAAI,GACF,MAAM,GAAC,SAAS,CAI5B"}

package/dist/polyfills/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./URL.js";
+export * from "./SyncBlobFile.js";
 export * from "./QuotaExceededError.js";
 export * from "./WebTransportError.js";
 export * from "./AudioData.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeson-registry",
-  "version": "14.1.0",
+  "version": "14.2.0",
   "description": "The type registry for typeson",
   "author": "dfahlander",
   "contributors": [

package/polyfills/SyncBlobFile.js

@@ -0,0 +1,97 @@
+// @ts-nocheck -- Uses `Buffer`, which has no types without `@types/node`
+//   (matches `URL.js`'s own `@ts-nocheck`, also Node-runtime-specific)
+// Node's native `Blob`/`File` only expose their bytes asynchronously
+//   (`.arrayBuffer()`/`.text()`/`.stream()`), with no standard synchronous
+//   accessor. `xmlHttpRequestOverrideMimeType` (see `URL.js`) needs
+//   synchronous access to back the `blob`/`file` types' synchronous
+//   `replace()`. For jsdom's own `Blob`/`File`, it gets this via jsdom's
+//   internal wrapper-unwrapping; for any other environment (e.g. Node
+//   without jsdom, as in a worker thread with no DOM), these
+//   `SyncBlob`/`SyncFile` subclasses provide the same synchronous access by
+//   capturing a copy of the content as a `Buffer`, at construction time,
+//   before handing the same `parts` off to the real, native constructor.
+//
+// The copy is kept in a module-private `WeakMap`, not as a property on the
+//   instance: a plain (even non-enumerable) property would let any code
+//   holding a reference to the `Blob`/`File` read its full raw content
+//   synchronously, bypassing the normal, async-only `Blob`/`File` API --
+//   and would risk leaking into `Object.keys()`/`JSON.stringify()`/etc. of
+//   an object that's supposed to look like an ordinary `Blob`/`File`. Only
+//   code that imports `getSyncBytes` from this same module can read it.
+
+/**
+ * @type {WeakMap<Blob, Buffer>}
+ */
+const syncBytesMap = new WeakMap();
+
+/**
+ * @param {Blob} blob A `SyncBlob`/`SyncFile` (or any `Blob`/`File` this
+ *   module has otherwise recorded bytes for).
+ * @returns {Buffer|undefined} `undefined` if `blob` isn't one this module
+ *   has a synchronous copy for.
+ */
+function getSyncBytes (blob) {
+    return syncBytesMap.get(blob);
+}
+
+/**
+ * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} parts
+ * @returns {Buffer}
+ */
+function partsToBuffer (parts) {
+    return Buffer.concat(parts.map((part) => {
+        if (typeof part === 'string') {
+            return Buffer.from(part, 'utf8');
+        }
+        if (Object.prototype.toString.call(part) === '[object ArrayBuffer]') {
+            return Buffer.from(/** @type {ArrayBuffer} */ (part));
+        }
+        if (ArrayBuffer.isView(part)) {
+            return Buffer.from(
+                part.buffer, part.byteOffset, part.byteLength
+            );
+        }
+        const partBytes = part && syncBytesMap.get(/** @type {Blob} */ (part));
+        if (partBytes) {
+            return partBytes;
+        }
+        return Buffer.from(String(part), 'utf8');
+    }));
+}
+
+/**
+ * A `Blob` subclass which also keeps a synchronously-readable copy of its
+ *   content (accessible only via `getSyncBytes`, not as a property of the
+ *   instance itself), for environments (e.g. Node without jsdom) where
+ *   `Blob` alone offers no synchronous way to read it back.
+ */
+class SyncBlob extends Blob {
+    /**
+     * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} [parts]
+     * @param {BlobPropertyBag} [options]
+     */
+    // eslint-disable-next-line @stylistic/max-len -- Long
+    // eslint-disable-next-line default-param-last -- Must match native `Blob` positionally
+    constructor (parts = [], options) {
+        super(parts, options);
+        syncBytesMap.set(this, partsToBuffer(parts));
+    }
+}
+
+/**
+ * `File` counterpart to `SyncBlob` -- see its documentation for why this
+ *   exists.
+ */
+class SyncFile extends File {
+    /**
+     * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} parts
+     * @param {string} name
+     * @param {FilePropertyBag} [options]
+     */
+    constructor (parts, name, options) {
+        super(parts, name, options);
+        syncBytesMap.set(this, partsToBuffer(parts));
+    }
+}
+
+export {SyncBlob, SyncFile, getSyncBytes};

package/polyfills/URL.js

@@ -14,6 +14,7 @@
 import {createRequire} from 'node:module';
 import whatwgURL from 'whatwg-url';
 import generateUUID from '../utils/generateUUID.js';
+import {getSyncBytes} from './SyncBlobFile.js';
 
 const require = createRequire(import.meta.url);
 const {implForWrapper} = require('jsdom/lib/generated/idl/utils.js');
@@ -53,6 +54,41 @@ const revokeObjectURL = function (blobURL) {
     delete blobURLs[blobURL];
 };
 
+/**
+ * Synchronously reads the content of a `Blob`/`File` previously registered
+ *   via `createObjectURL`. `SyncBlob`/`SyncFile` (see `SyncBlobFile.js`)
+ *   keep their own synchronously-readable copy of the content for
+ *   environments without jsdom (e.g. Node on its own); prefer that if
+ *   present, falling back to jsdom's internal wrapper-unwrapping otherwise.
+ * @param {Blob} blob
+ * @returns {Buffer|undefined}
+ */
+const getBlobBytesSync = function (blob) {
+    return getSyncBytes(blob) || implForWrapper(blob)?._bytes;
+};
+
+/**
+ * Resolves a `blob:` URL (previously registered via `createObjectURL`) back
+ *   to its content, synchronously -- for use by any XHR/`fetch` polyfill
+ *   that needs to serve `blob:` URLs itself (mirroring how browsers read
+ *   `blob:` URLs without going over the network).
+ * @param {string} blobURL
+ * @returns {{type: string, bytes: Buffer}|undefined} `undefined` if
+ *   `blobURL` is not (or is no longer) a registered `blob:` URL.
+ */
+const resolveObjectURL = function (blobURL) {
+    const blob = blobURLs[blobURL];
+    if (!blob) {
+        return undefined;
+    }
+    // eslint-disable-next-line n/no-sync -- Deliberate
+    const bytes = getBlobBytesSync(blob);
+    if (!bytes) {
+        return undefined;
+    }
+    return {type: blob.type, bytes};
+};
+
 // We only handle the case of binary, so no need to override `open`
 //   in all cases; but this only works if override is called first
 
@@ -98,11 +134,13 @@ const xmlHttpRequestOverrideMimeType = function (
                     }
                     const responseType = 'text/plain'; // blob.type;
                     // utf16le and base64 both convert lone surrogates
-                    const blobImpl = implForWrapper(blob);
+
+                    // eslint-disable-next-line n/no-sync -- Deliberate
+                    const syncBytes = getBlobBytesSync(blob);
                     // jsdom changed Blob internals from `_buffer`
                     // to `_bytes`; support both.
                     const encoded =
-                        Buffer.from(blobImpl._bytes).toString('binary');
+                        Buffer.from(syncBytes).toString('binary');
 
                     // Not usable in jsdom which makes properties readonly,
                     //   but local-xmlhttprequest can use (and jsdom can
@@ -133,4 +171,7 @@ const xmlHttpRequestOverrideMimeType = function (
     };
 };
 
-export {createObjectURL, xmlHttpRequestOverrideMimeType, revokeObjectURL};
+export {
+    createObjectURL, xmlHttpRequestOverrideMimeType, revokeObjectURL,
+    resolveObjectURL, getBlobBytesSync
+};

package/polyfills/index.cjs

@@ -3342,6 +3342,111 @@ function generateUUID() {
   });
 }
 
+// @ts-nocheck -- Uses `Buffer`, which has no types without `@types/node`
+//   (matches `URL.js`'s own `@ts-nocheck`, also Node-runtime-specific)
+// Node's native `Blob`/`File` only expose their bytes asynchronously
+//   (`.arrayBuffer()`/`.text()`/`.stream()`), with no standard synchronous
+//   accessor. `xmlHttpRequestOverrideMimeType` (see `URL.js`) needs
+//   synchronous access to back the `blob`/`file` types' synchronous
+//   `replace()`. For jsdom's own `Blob`/`File`, it gets this via jsdom's
+//   internal wrapper-unwrapping; for any other environment (e.g. Node
+//   without jsdom, as in a worker thread with no DOM), these
+//   `SyncBlob`/`SyncFile` subclasses provide the same synchronous access by
+//   capturing a copy of the content as a `Buffer`, at construction time,
+//   before handing the same `parts` off to the real, native constructor.
+//
+// The copy is kept in a module-private `WeakMap`, not as a property on the
+//   instance: a plain (even non-enumerable) property would let any code
+//   holding a reference to the `Blob`/`File` read its full raw content
+//   synchronously, bypassing the normal, async-only `Blob`/`File` API --
+//   and would risk leaking into `Object.keys()`/`JSON.stringify()`/etc. of
+//   an object that's supposed to look like an ordinary `Blob`/`File`. Only
+//   code that imports `getSyncBytes` from this same module can read it.
+
+/**
+ * @type {WeakMap<Blob, Buffer>}
+ */
+var syncBytesMap = new WeakMap();
+
+/**
+ * @param {Blob} blob A `SyncBlob`/`SyncFile` (or any `Blob`/`File` this
+ *   module has otherwise recorded bytes for).
+ * @returns {Buffer|undefined} `undefined` if `blob` isn't one this module
+ *   has a synchronous copy for.
+ */
+function getSyncBytes(blob) {
+  return syncBytesMap.get(blob);
+}
+
+/**
+ * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} parts
+ * @returns {Buffer}
+ */
+function partsToBuffer(parts) {
+  return Buffer.concat(parts.map(function (part) {
+    if (typeof part === 'string') {
+      return Buffer.from(part, 'utf8');
+    }
+    if (Object.prototype.toString.call(part) === '[object ArrayBuffer]') {
+      return Buffer.from(/** @type {ArrayBuffer} */part);
+    }
+    if (ArrayBuffer.isView(part)) {
+      return Buffer.from(part.buffer, part.byteOffset, part.byteLength);
+    }
+    var partBytes = part && syncBytesMap.get(/** @type {Blob} */part);
+    if (partBytes) {
+      return partBytes;
+    }
+    return Buffer.from(String(part), 'utf8');
+  }));
+}
+
+/**
+ * A `Blob` subclass which also keeps a synchronously-readable copy of its
+ *   content (accessible only via `getSyncBytes`, not as a property of the
+ *   instance itself), for environments (e.g. Node without jsdom) where
+ *   `Blob` alone offers no synchronous way to read it back.
+ */
+var SyncBlob = /*#__PURE__*/function (_Blob) {
+  /**
+   * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} [parts]
+   * @param {BlobPropertyBag} [options]
+   */
+  // eslint-disable-next-line @stylistic/max-len -- Long
+  // eslint-disable-next-line default-param-last -- Must match native `Blob` positionally
+  function SyncBlob() {
+    var _this;
+    var parts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var options = arguments.length > 1 ? arguments[1] : undefined;
+    _classCallCheck(this, SyncBlob);
+    _this = _callSuper(this, SyncBlob, [parts, options]);
+    syncBytesMap.set(_this, partsToBuffer(parts));
+    return _this;
+  }
+  _inherits(SyncBlob, _Blob);
+  return _createClass(SyncBlob);
+}(/*#__PURE__*/_wrapNativeSuper(Blob));
+/**
+ * `File` counterpart to `SyncBlob` -- see its documentation for why this
+ *   exists.
+ */
+var SyncFile = /*#__PURE__*/function (_File) {
+  /**
+   * @param {(string|ArrayBuffer|ArrayBufferView|Blob)[]} parts
+   * @param {string} name
+   * @param {FilePropertyBag} [options]
+   */
+  function SyncFile(parts, name, options) {
+    var _this2;
+    _classCallCheck(this, SyncFile);
+    _this2 = _callSuper(this, SyncFile, [parts, name, options]);
+    syncBytesMap.set(_this2, partsToBuffer(parts));
+    return _this2;
+  }
+  _inherits(SyncFile, _File);
+  return _createClass(SyncFile);
+}(/*#__PURE__*/_wrapNativeSuper(File));
+
 /* eslint-disable unicorn/no-this-outside-of-class -- Monkey-patching */
 // @ts-nocheck -- jsdom has no types for the file we need
 /* globals location, XMLHttpRequest -- Polyfills */
@@ -3380,6 +3485,45 @@ var revokeObjectURL = function revokeObjectURL(blobURL) {
   delete blobURLs[blobURL];
 };
 
+/**
+ * Synchronously reads the content of a `Blob`/`File` previously registered
+ *   via `createObjectURL`. `SyncBlob`/`SyncFile` (see `SyncBlobFile.js`)
+ *   keep their own synchronously-readable copy of the content for
+ *   environments without jsdom (e.g. Node on its own); prefer that if
+ *   present, falling back to jsdom's internal wrapper-unwrapping otherwise.
+ * @param {Blob} blob
+ * @returns {Buffer|undefined}
+ */
+var getBlobBytesSync = function getBlobBytesSync(blob) {
+  var _implForWrapper;
+  return getSyncBytes(blob) || ((_implForWrapper = implForWrapper(blob)) === null || _implForWrapper === void 0 ? void 0 : _implForWrapper._bytes);
+};
+
+/**
+ * Resolves a `blob:` URL (previously registered via `createObjectURL`) back
+ *   to its content, synchronously -- for use by any XHR/`fetch` polyfill
+ *   that needs to serve `blob:` URLs itself (mirroring how browsers read
+ *   `blob:` URLs without going over the network).
+ * @param {string} blobURL
+ * @returns {{type: string, bytes: Buffer}|undefined} `undefined` if
+ *   `blobURL` is not (or is no longer) a registered `blob:` URL.
+ */
+var resolveObjectURL = function resolveObjectURL(blobURL) {
+  var blob = blobURLs[blobURL];
+  if (!blob) {
+    return undefined;
+  }
+  // eslint-disable-next-line n/no-sync -- Deliberate
+  var bytes = getBlobBytesSync(blob);
+  if (!bytes) {
+    return undefined;
+  }
+  return {
+    type: blob.type,
+    bytes: bytes
+  };
+};
+
 // We only handle the case of binary, so no need to override `open`
 //   in all cases; but this only works if override is called first
 
@@ -3420,10 +3564,12 @@ var xmlHttpRequestOverrideMimeType = function xmlHttpRequestOverrideMimeType() {
           }
           var responseType = 'text/plain'; // blob.type;
           // utf16le and base64 both convert lone surrogates
-          var blobImpl = implForWrapper(blob);
+
+          // eslint-disable-next-line n/no-sync -- Deliberate
+          var syncBytes = getBlobBytesSync(blob);
           // jsdom changed Blob internals from `_buffer`
           // to `_bytes`; support both.
-          var encoded = Buffer.from(blobImpl._bytes).toString('binary');
+          var encoded = Buffer.from(syncBytes).toString('binary');
 
           // Not usable in jsdom which makes properties readonly,
           //   but local-xmlhttprequest can use (and jsdom can
@@ -4692,10 +4838,15 @@ exports.DOMRectReadOnly = DOMRectReadOnly;
 exports.EncodedAudioChunk = EncodedAudioChunk;
 exports.EncodedVideoChunk = EncodedVideoChunk;
 exports.QuotaExceededError = QuotaExceededError;
+exports.SyncBlob = SyncBlob;
+exports.SyncFile = SyncFile;
 exports.VideoFrame = VideoFrame;
 exports.WebTransportError = WebTransportError;
 exports.createImageBitmap = createImageBitmap;
 exports.createObjectURL = createObjectURL;
+exports.getBlobBytesSync = getBlobBytesSync;
+exports.getSyncBytes = getSyncBytes;
+exports.resolveObjectURL = resolveObjectURL;
 exports.revokeObjectURL = revokeObjectURL;
 exports.xmlHttpRequestOverrideMimeType = xmlHttpRequestOverrideMimeType;
 //# sourceMappingURL=index.cjs.map