@warp-drive-mirror/experiments 0.2.7-beta.0 → 0.2.7-beta.2

package/dist/image-fetch.js

@@ -1,80 +1,109 @@
-import { createDeferred } from '@warp-drive-mirror/core/request';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
+import { getGlobalConfig, macroCondition } from "@embroider/macros";
+import { createDeferred } from "@warp-drive-mirror/core/request";
 
-// @ts-expect-error untyped global
-const isServerEnv = typeof FastBoot !== 'undefined';
-class ImageFetch {
-  constructor(worker) {
-    this.threadId = isServerEnv ? '' : crypto.randomUUID();
-    this.pending = new Map();
-    this.cache = new Map();
-    const isTesting = macroCondition(getGlobalConfig().WarpDriveMirror.env.TESTING) ? true : false;
-    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected a SharedWorker instance`);
-      }
-    })(isTesting || isServerEnv || worker instanceof SharedWorker) : {};
-    this.worker = worker;
-    if (!isServerEnv) {
-      const fn = event => {
-        const {
-          type,
-          url
-        } = event.data;
-        const deferred = this.cleanupRequest(url);
-        if (!deferred) {
-          return;
-        }
-        if (type === 'success-response') {
-          deferred.resolve(url);
-          return;
-        }
-        if (type === 'error-response') {
-          deferred.reject(null);
-          return;
-        }
-      };
-      if (worker instanceof SharedWorker) {
-        worker.port.postMessage({
-          type: 'connect',
-          thread: this.threadId
-        });
-        worker.port.onmessage = fn;
-      } else if (worker) {
-        this.channel = new MessageChannel();
-        worker.postMessage({
-          type: 'connect',
-          thread: this.threadId
-        }, [this.channel.port2]);
-        this.channel.port1.onmessage = fn;
-      }
-    }
-  }
-  cleanupRequest(url) {
-    const deferred = this.pending.get(url);
-    this.pending.delete(url);
-    return deferred;
-  }
-  _send(event) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
-  }
-  load(url) {
-    if (isServerEnv) {
-      return Promise.resolve(url);
-    }
-    const objectUrl = this.cache.get(url);
-    if (objectUrl) {
-      return Promise.resolve(objectUrl);
-    }
-    const deferred = createDeferred();
-    this.pending.set(url, deferred);
-    this._send({
-      type: 'load',
-      thread: this.threadId,
-      url
-    });
-    return deferred.promise;
-  }
-}
-export { ImageFetch };
+//#region src/image-worker/fetch.ts
+const isServerEnv = typeof FastBoot !== "undefined";
+/**
+* Main-thread client for an {@link ImageWorker}. Sends image `load`
+* requests to a `Worker` or `SharedWorker` running an `ImageWorker`.
+*
+* In FastBoot/SSR, or when constructed with a `null` worker, `ImageFetch`
+* skips worker communication entirely: {@link ImageFetch.load} resolves
+* immediately with the given url.
+*
+* A plain `Worker` is only accepted when running in a `TESTING` build;
+* production usage requires a `SharedWorker`.
+*
+* @public
+*/
+var ImageFetch = class {
+	/**
+	* @param worker - the `Worker` or `SharedWorker` running an
+	* {@link ImageWorker}, or `null` to disable worker communication (e.g.
+	* in FastBoot/SSR).
+	*/
+	constructor(worker) {
+		this.threadId = isServerEnv ? "" : crypto.randomUUID();
+		this.pending = /* @__PURE__ */ new Map();
+		this.cache = /* @__PURE__ */ new Map();
+		const isTesting = macroCondition(getGlobalConfig().WarpDriveMirror.env.TESTING) ? true : false;
+		macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) && ((test) => {
+			if (!test) throw new Error(`Expected a SharedWorker instance`);
+		})(isTesting || isServerEnv || worker instanceof SharedWorker);
+		this.worker = worker;
+		if (!isServerEnv) {
+			const fn = (event) => {
+				const { type, url } = event.data;
+				const deferred = this.cleanupRequest(url);
+				if (!deferred) return;
+				if (type === "success-response") {
+					const { objectUrl } = event.data;
+					this.cache.set(url, objectUrl);
+					deferred.resolve(objectUrl);
+					return;
+				}
+				if (type === "error-response") {
+					deferred.reject(null);
+					return;
+				}
+			};
+			if (worker instanceof SharedWorker) {
+				worker.port.postMessage({
+					type: "connect",
+					thread: this.threadId
+				});
+				worker.port.onmessage = fn;
+			} else if (worker) {
+				this.channel = new MessageChannel();
+				worker.postMessage({
+					type: "connect",
+					thread: this.threadId
+				}, [this.channel.port2]);
+				this.channel.port1.onmessage = fn;
+			}
+		}
+	}
+	cleanupRequest(url) {
+		const deferred = this.pending.get(url);
+		this.pending.delete(url);
+		return deferred;
+	}
+	_send(event) {
+		this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
+	}
+	/**
+	* Requests that the given image url be loaded by the connected
+	* {@link ImageWorker}, resolving with an object url for the fetched
+	* image's blob once the worker responds (or immediately with the
+	* original `url`, in SSR/FastBoot or when this instance was constructed
+	* with a `null` worker).
+	*
+	* The resolved object url is cached in-memory by source url on this
+	* instance, so subsequent calls for the same url resolve immediately
+	* without another round-trip to the worker.
+	*
+	* Calling `load` again for a url that is already in-flight (not yet
+	* cached) on this instance replaces the pending request rather than
+	* joining it — only the most recently issued call for a given url will
+	* resolve.
+	*
+	* @public
+	*/
+	load(url) {
+		if (isServerEnv) return Promise.resolve(url);
+		const objectUrl = this.cache.get(url);
+		if (objectUrl) return Promise.resolve(objectUrl);
+		const deferred = createDeferred();
+		this.pending.set(url, deferred);
+		this._send({
+			type: "load",
+			thread: this.threadId,
+			url
+		});
+		return deferred.promise;
+	}
+};
+
+//#endregion
+export { ImageFetch };
+//# sourceMappingURL=image-fetch.js.map

package/dist/image-fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-fetch.js","names":["createDeferred","getGlobalConfig","macroCondition","isServerEnv","FastBoot","ImageFetch","constructor","worker","threadId","crypto","randomUUID","pending","Map","cache","isTesting","WarpDrive","env","TESTING","DEBUG","test","Error","SharedWorker","fn","event","type","url","data","deferred","cleanupRequest","objectUrl","set","resolve","reject","port","postMessage","thread","onmessage","channel","MessageChannel","port2","port1","get","delete","_send","load","Promise","promise"],"sources":["../src/image-worker/fetch.ts"],"sourcesContent":["import { TESTING } from '@warp-drive-mirror/core/build-config/env';\nimport { assert } from '@warp-drive-mirror/core/build-config/macros';\nimport type { Deferred } from '@warp-drive-mirror/core/request';\nimport { createDeferred } from '@warp-drive-mirror/core/request';\n\nimport type { MainThreadEvent, RequestEventData } from './types';\n// oxlint-disable-next-line no-unused-vars\nimport type { ImageWorker } from './worker';\n\nexport interface FastBoot {\n  require(moduleName: string): unknown;\n  isFastBoot: boolean;\n  request: Request;\n}\n\n// @ts-expect-error untyped global\nconst isServerEnv = typeof FastBoot !== 'undefined';\n\n/**\n * Main-thread client for an {@link ImageWorker}. Sends image `load`\n * requests to a `Worker` or `SharedWorker` running an `ImageWorker`.\n *\n * In FastBoot/SSR, or when constructed with a `null` worker, `ImageFetch`\n * skips worker communication entirely: {@link ImageFetch.load} resolves\n * immediately with the given url.\n *\n * A plain `Worker` is only accepted when running in a `TESTING` build;\n * production usage requires a `SharedWorker`.\n *\n * @public\n */\nexport class ImageFetch {\n  declare worker: Worker | SharedWorker;\n  declare threadId: string;\n  declare pending: Map<string, Deferred<string>>;\n  declare channel: MessageChannel;\n  declare cache: Map<string, string>;\n\n  /**\n   * @param worker - the `Worker` or `SharedWorker` running an\n   * {@link ImageWorker}, or `null` to disable worker communication (e.g.\n   * in FastBoot/SSR).\n   */\n  constructor(worker: Worker | SharedWorker | null) {\n    this.threadId = isServerEnv ? '' : crypto.randomUUID();\n    this.pending = new Map();\n    this.cache = new Map();\n\n    const isTesting = TESTING ? true : false;\n    assert(`Expected a SharedWorker instance`, isTesting || isServerEnv || worker instanceof SharedWorker);\n    this.worker = worker as SharedWorker;\n\n    if (!isServerEnv) {\n      const fn = (event: MainThreadEvent) => {\n        const { type, url } = event.data;\n        const deferred = this.cleanupRequest(url);\n        if (!deferred) {\n          return;\n        }\n\n        if (type === 'success-response') {\n          const { objectUrl } = event.data;\n          this.cache.set(url, objectUrl);\n          deferred.resolve(objectUrl);\n          return;\n        }\n\n        if (type === 'error-response') {\n          deferred.reject(null);\n          return;\n        }\n      };\n\n      if (worker instanceof SharedWorker) {\n        worker.port.postMessage({ type: 'connect', thread: this.threadId });\n        worker.port.onmessage = fn;\n      } else if (worker) {\n        this.channel = new MessageChannel();\n        worker.postMessage({ type: 'connect', thread: this.threadId }, [this.channel.port2]);\n\n        this.channel.port1.onmessage = fn;\n      }\n    }\n  }\n\n  cleanupRequest(url: string): Deferred<string> | undefined {\n    const deferred = this.pending.get(url);\n    this.pending.delete(url);\n\n    return deferred;\n  }\n\n  _send(event: RequestEventData): void {\n    // oxlint-disable-next-line no-unused-expressions\n    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);\n  }\n\n  /**\n   * Requests that the given image url be loaded by the connected\n   * {@link ImageWorker}, resolving with an object url for the fetched\n   * image's blob once the worker responds (or immediately with the\n   * original `url`, in SSR/FastBoot or when this instance was constructed\n   * with a `null` worker).\n   *\n   * The resolved object url is cached in-memory by source url on this\n   * instance, so subsequent calls for the same url resolve immediately\n   * without another round-trip to the worker.\n   *\n   * Calling `load` again for a url that is already in-flight (not yet\n   * cached) on this instance replaces the pending request rather than\n   * joining it — only the most recently issued call for a given url will\n   * resolve.\n   *\n   * @public\n   */\n  load(url: string): Promise<string> {\n    if (isServerEnv) {\n      return Promise.resolve(url);\n    }\n\n    const objectUrl = this.cache.get(url);\n    if (objectUrl) {\n      return Promise.resolve(objectUrl);\n    }\n\n    const deferred = createDeferred<string>();\n    this.pending.set(url, deferred);\n    this._send({ type: 'load', thread: this.threadId, url });\n    return deferred.promise;\n  }\n}\n"],"mappings":";;;;AAgBA,MAAMG,cAAc,OAAOC,aAAa;;;;;;;;;;;;;;AAexC,IAAaC,aAAb,MAAwB;;;;;;CAYtBC,YAAYC,QAAsC;EAChD,KAAKC,WAAWL,cAAc,KAAKM,OAAOC,WAAW;EACrD,KAAKC,0BAAU,IAAIC,IAAI;EACvB,KAAKC,wBAAQ,IAAID,IAAI;EAErB,MAAME,YAAYZ,eAAAD,gBAAA,CAAA,CAAAc,UAAAC,IAAAC,OAAA,IAAU,OAAO;EACnCf,eAAAD,gBAAA,CAAA,CAAAc,UAAAC,IAAAE,KAAA,OAAAC,SAAA;GAAA,IAAA,CAAAA,MAAA,MAAA,IAAAC,MAAO,kCAAkC;EAAA,EAAA,CAAEN,aAAaX,eAAeI,kBAAkBc,YAAY;EACrG,KAAKd,SAASA;EAEd,IAAI,CAACJ,aAAa;GAChB,MAAMmB,MAAMC,UAA2B;IACrC,MAAM,EAAEC,MAAMC,QAAQF,MAAMG;IAC5B,MAAMC,WAAW,KAAKC,eAAeH,GAAG;IACxC,IAAI,CAACE,UACH;IAGF,IAAIH,SAAS,oBAAoB;KAC/B,MAAM,EAAEK,cAAcN,MAAMG;KAC5B,KAAKb,MAAMiB,IAAIL,KAAKI,SAAS;KAC7BF,SAASI,QAAQF,SAAS;KAC1B;IACF;IAEA,IAAIL,SAAS,kBAAkB;KAC7BG,SAASK,OAAO,IAAI;KACpB;IACF;GACF;GAEA,IAAIzB,kBAAkBc,cAAc;IAClCd,OAAO0B,KAAKC,YAAY;KAAEV,MAAM;KAAWW,QAAQ,KAAK3B;IAAS,CAAC;IAClED,OAAO0B,KAAKG,YAAYd;GAC1B,OAAO,IAAIf,QAAQ;IACjB,KAAK8B,UAAU,IAAIC,eAAe;IAClC/B,OAAO2B,YAAY;KAAEV,MAAM;KAAWW,QAAQ,KAAK3B;IAAS,GAAG,CAAC,KAAK6B,QAAQE,KAAK,CAAC;IAEnF,KAAKF,QAAQG,MAAMJ,YAAYd;GACjC;EACF;CACF;CAEAM,eAAeH,KAA2C;EACxD,MAAME,WAAW,KAAKhB,QAAQ8B,IAAIhB,GAAG;EACrC,KAAKd,QAAQ+B,OAAOjB,GAAG;EAEvB,OAAOE;CACT;CAEAgB,MAAMpB,OAA+B;EAEnC,KAAKhB,kBAAkBc,eAAe,KAAKd,OAAO0B,KAAKC,YAAYX,KAAK,IAAI,KAAKc,QAAQG,MAAMN,YAAYX,KAAK;CAClH;;;;;;;;;;;;;;;;;;;CAoBAqB,KAAKnB,KAA8B;EACjC,IAAItB,aACF,OAAO0C,QAAQd,QAAQN,GAAG;EAG5B,MAAMI,YAAY,KAAKhB,MAAM4B,IAAIhB,GAAG;EACpC,IAAII,WACF,OAAOgB,QAAQd,QAAQF,SAAS;EAGlC,MAAMF,WAAW3B,eAAuB;EACxC,KAAKW,QAAQmB,IAAIL,KAAKE,QAAQ;EAC9B,KAAKgB,MAAM;GAAEnB,MAAM;GAAQW,QAAQ,KAAK3B;GAAUiB;EAAI,CAAC;EACvD,OAAOE,SAASmB;CAClB;AACF"}

package/dist/image-worker.d.ts

@@ -0,0 +1,40 @@
+//#region src/image-worker/worker.d.ts
+/**
+ * Runs inside a `Worker` or `SharedWorker` to fetch images on behalf of
+ * one or more {@link ImageFetch} instances running on the main thread(s)
+ * that connect to it.
+ *
+ * Each connecting thread registers itself by sending a `connect` message
+ * along with a {@link MessagePort}. When a thread sends a `load` request
+ * for a url, the worker fetches the image via `fetch`, converts the
+ * response into a `Blob`, and creates an object url for it via
+ * `URL.createObjectURL`. The fetch for a given url is deduped and cached
+ * in-memory for the lifetime of the worker, so repeat `load` requests for
+ * the same url — whether from the same or a different connected thread —
+ * do not trigger another network request.
+ *
+ * Only intended for use inside a Worker context: constructing an
+ * `ImageWorker` on the main thread is a no-op.
+ *
+ * @public
+ */
+declare class ImageWorker {
+  private threads;
+  private pendingImages;
+  private options;
+  private isSharedWorker;
+  private cache;
+  /**
+   * @param options.persisted - reserved for a future on-disk cache; currently unused.
+   */
+  constructor(options?: {
+    persisted: boolean;
+  });
+  private fetch;
+  private initialize;
+  private setupThread;
+  private request;
+}
+//#endregion
+export { ImageWorker };
+//# sourceMappingURL=image-worker.d.ts.map

package/dist/image-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-worker.d.ts","names":[],"sources":["../src/image-worker/worker.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cA+Ba;UACK;UACA;UACA;UACA;UACA;;;;EAKhB,YAAY;IAAY;;UAahB;UAsBA;UA4BA;UAiBM"}

package/dist/image-worker.js

@@ -1,98 +1,98 @@
+//#region src/image-worker/worker.ts
 const WorkerScope = globalThis.SharedWorkerGlobalScope;
 async function loadImage(url) {
-  const response = await fetch(url);
-  const fileBlob = await response.blob();
-  return URL.createObjectURL(fileBlob);
+	const fileBlob = await (await fetch(url)).blob();
+	return URL.createObjectURL(fileBlob);
 }
-class ImageWorker {
-  constructor(options) {
-    // disable if running on main thread
-    if (typeof window !== 'undefined') {
-      return;
-    }
-    this.threads = new Map();
-    this.pendingImages = new Map();
-    this.cache = new Map();
-    this.options = options || {
-      persisted: false
-    };
-    this.isSharedWorker = WorkerScope && globalThis instanceof WorkerScope;
-    this.initialize();
-  }
-  fetch(url) {
-    const objectUrl = this.cache.get(url);
-    if (objectUrl) {
-      return Promise.resolve(objectUrl);
-    }
-    const pending = this.pendingImages.get(url);
-    if (pending) {
-      return pending;
-    }
-    const promise = loadImage(url);
-    this.pendingImages.set(url, promise);
-    return promise.finally(() => {
-      this.pendingImages.delete(url);
-    });
-  }
-  initialize() {
-    if (this.isSharedWorker) {
-      globalThis.onconnect = e => {
-        const port = e.ports[0];
-        port.onmessage = event => {
-          const {
-            type
-          } = event.data;
-          switch (type) {
-            case 'connect':
-              this.setupThread(event.data.thread, port);
-              break;
-          }
-        };
-        port.start();
-      };
-    } else {
-      globalThis.onmessage = event => {
-        const {
-          type
-        } = event.data;
-        switch (type) {
-          case 'connect':
-            this.setupThread(event.data.thread, event.ports[0]);
-            break;
-        }
-      };
-    }
-  }
-  setupThread(thread, port) {
-    this.threads.set(thread, port);
-    port.onmessage = event => {
-      if (event.type === 'close') {
-        this.threads.delete(thread);
-        return;
-      }
-      const {
-        type
-      } = event.data;
-      switch (type) {
-        case 'load':
-          void this.request(event.data);
-          break;
-      }
-    };
-  }
-  async request(event) {
-    const {
-      thread,
-      url
-    } = event;
-    const objectUrl = await this.fetch(url);
-    const port = this.threads.get(thread);
-    port.postMessage({
-      type: 'success-response',
-      thread,
-      url,
-      objectUrl
-    });
-  }
-}
-export { ImageWorker };
+/**
+* Runs inside a `Worker` or `SharedWorker` to fetch images on behalf of
+* one or more {@link ImageFetch} instances running on the main thread(s)
+* that connect to it.
+*
+* Each connecting thread registers itself by sending a `connect` message
+* along with a {@link MessagePort}. When a thread sends a `load` request
+* for a url, the worker fetches the image via `fetch`, converts the
+* response into a `Blob`, and creates an object url for it via
+* `URL.createObjectURL`. The fetch for a given url is deduped and cached
+* in-memory for the lifetime of the worker, so repeat `load` requests for
+* the same url — whether from the same or a different connected thread —
+* do not trigger another network request.
+*
+* Only intended for use inside a Worker context: constructing an
+* `ImageWorker` on the main thread is a no-op.
+*
+* @public
+*/
+var ImageWorker = class {
+	/**
+	* @param options.persisted - reserved for a future on-disk cache; currently unused.
+	*/
+	constructor(options) {
+		if (typeof window !== "undefined") return;
+		this.threads = /* @__PURE__ */ new Map();
+		this.pendingImages = /* @__PURE__ */ new Map();
+		this.cache = /* @__PURE__ */ new Map();
+		this.options = options || { persisted: false };
+		this.isSharedWorker = WorkerScope && globalThis instanceof WorkerScope;
+		this.initialize();
+	}
+	fetch(url) {
+		const objectUrl = this.cache.get(url);
+		if (objectUrl) return Promise.resolve(objectUrl);
+		const pending = this.pendingImages.get(url);
+		if (pending) return pending;
+		const promise = loadImage(url).then((loadedObjectUrl) => {
+			this.cache.set(url, loadedObjectUrl);
+			return loadedObjectUrl;
+		});
+		this.pendingImages.set(url, promise);
+		return promise.finally(() => {
+			this.pendingImages.delete(url);
+		});
+	}
+	initialize() {
+		if (this.isSharedWorker) globalThis.onconnect = (e) => {
+			const port = e.ports[0];
+			port.onmessage = (event) => {
+				const { type } = event.data;
+				switch (type) {
+					case "connect": this.setupThread(event.data.thread, port);
+				}
+			};
+			port.start();
+		};
+		else globalThis.onmessage = (event) => {
+			const { type } = event.data;
+			switch (type) {
+				case "connect": this.setupThread(event.data.thread, event.ports[0]);
+			}
+		};
+	}
+	setupThread(thread, port) {
+		this.threads.set(thread, port);
+		port.onmessage = (event) => {
+			if (event.type === "close") {
+				this.threads.delete(thread);
+				return;
+			}
+			const { type } = event.data;
+			switch (type) {
+				case "load": this.request(event.data);
+			}
+		};
+	}
+	async request(event) {
+		const { thread, url } = event;
+		const objectUrl = await this.fetch(url);
+		this.threads.get(thread).postMessage({
+			type: "success-response",
+			thread,
+			url,
+			objectUrl
+		});
+	}
+};
+
+//#endregion
+export { ImageWorker };
+//# sourceMappingURL=image-worker.js.map

package/dist/image-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-worker.js","names":["WorkerScope","globalThis","SharedWorkerGlobalScope","loadImage","url","response","fetch","fileBlob","blob","URL","createObjectURL","ImageWorker","constructor","options","window","threads","Map","pendingImages","cache","persisted","isSharedWorker","initialize","objectUrl","get","Promise","resolve","pending","promise","then","loadedObjectUrl","set","finally","delete","onconnect","e","port","ports","onmessage","event","type","data","setupThread","thread","start","request","postMessage"],"sources":["../src/image-worker/worker.ts"],"sourcesContent":["// oxlint-disable-next-line no-unused-vars\nimport type { ImageFetch } from './fetch';\nimport type { RequestEventData, ThreadInitEventData, WorkerThreadEvent } from './types';\n\nconst WorkerScope = (globalThis as unknown as { SharedWorkerGlobalScope: FunctionConstructor }).SharedWorkerGlobalScope;\n\nasync function loadImage(url: string): Promise<string> {\n  const response = await fetch(url);\n  const fileBlob = await response.blob();\n  return URL.createObjectURL(fileBlob);\n}\n\n/**\n * Runs inside a `Worker` or `SharedWorker` to fetch images on behalf of\n * one or more {@link ImageFetch} instances running on the main thread(s)\n * that connect to it.\n *\n * Each connecting thread registers itself by sending a `connect` message\n * along with a {@link MessagePort}. When a thread sends a `load` request\n * for a url, the worker fetches the image via `fetch`, converts the\n * response into a `Blob`, and creates an object url for it via\n * `URL.createObjectURL`. The fetch for a given url is deduped and cached\n * in-memory for the lifetime of the worker, so repeat `load` requests for\n * the same url — whether from the same or a different connected thread —\n * do not trigger another network request.\n *\n * Only intended for use inside a Worker context: constructing an\n * `ImageWorker` on the main thread is a no-op.\n *\n * @public\n */\nexport class ImageWorker {\n  declare private threads: Map<string, MessagePort>;\n  declare private pendingImages: Map<string, Promise<string>>;\n  declare private options: { persisted: boolean };\n  declare private isSharedWorker: boolean;\n  declare private cache: Map<string, string>;\n\n  /**\n   * @param options.persisted - reserved for a future on-disk cache; currently unused.\n   */\n  constructor(options?: { persisted: boolean }) {\n    // disable if running on main thread\n    if (typeof window !== 'undefined') {\n      return;\n    }\n    this.threads = new Map();\n    this.pendingImages = new Map();\n    this.cache = new Map();\n    this.options = options || { persisted: false };\n    this.isSharedWorker = WorkerScope && globalThis instanceof WorkerScope;\n    this.initialize();\n  }\n\n  private fetch(url: string): Promise<string> {\n    const objectUrl = this.cache.get(url);\n\n    if (objectUrl) {\n      return Promise.resolve(objectUrl);\n    }\n\n    const pending = this.pendingImages.get(url);\n    if (pending) {\n      return pending;\n    }\n\n    const promise = loadImage(url).then((loadedObjectUrl) => {\n      this.cache.set(url, loadedObjectUrl);\n      return loadedObjectUrl;\n    });\n    this.pendingImages.set(url, promise);\n    return promise.finally(() => {\n      this.pendingImages.delete(url);\n    });\n  }\n\n  private initialize(): void {\n    if (this.isSharedWorker) {\n      (globalThis as unknown as { onconnect: typeof globalThis.onmessage }).onconnect = (e) => {\n        const port = e.ports[0];\n        port.onmessage = (event: MessageEvent<ThreadInitEventData>) => {\n          const { type } = event.data;\n\n          switch (type) {\n            case 'connect':\n              this.setupThread(event.data.thread, port);\n              break;\n          }\n        };\n        port.start();\n      };\n    } else {\n      globalThis.onmessage = (event: MessageEvent<ThreadInitEventData>) => {\n        const { type } = event.data;\n\n        switch (type) {\n          case 'connect':\n            this.setupThread(event.data.thread, event.ports[0]);\n            break;\n        }\n      };\n    }\n  }\n\n  private setupThread(thread: string, port: MessagePort): void {\n    this.threads.set(thread, port);\n    port.onmessage = (event: WorkerThreadEvent) => {\n      if (event.type === 'close') {\n        this.threads.delete(thread);\n        return;\n      }\n\n      const { type } = event.data;\n      switch (type) {\n        case 'load':\n          void this.request(event.data);\n          break;\n      }\n    };\n  }\n\n  private async request(event: RequestEventData): Promise<void> {\n    const { thread, url } = event;\n\n    const objectUrl = await this.fetch(url);\n    const port = this.threads.get(thread)!;\n    port.postMessage({ type: 'success-response', thread, url, objectUrl });\n  }\n}\n"],"mappings":";AAIA,MAAMA,cAAeC,WAA2EC;AAEhG,eAAeC,UAAUC,KAA8B;CAErD,MAAMG,WAAW,OAAMF,MADAC,MAAMF,GAAG,EACD,CAACI,KAAK;CACrC,OAAOC,IAAIC,gBAAgBH,QAAQ;AACrC;;;;;;;;;;;;;;;;;;;;AAqBA,IAAaI,cAAb,MAAyB;;;;CAUvBC,YAAYC,SAAkC;EAE5C,IAAI,OAAOC,WAAW,aACpB;EAEF,KAAKC,0BAAU,IAAIC,IAAI;EACvB,KAAKC,gCAAgB,IAAID,IAAI;EAC7B,KAAKE,wBAAQ,IAAIF,IAAI;EACrB,KAAKH,UAAUA,WAAW,EAAEM,WAAW,MAAM;EAC7C,KAAKC,iBAAiBpB,eAAeC,sBAAsBD;EAC3D,KAAKqB,WAAW;CAClB;CAEQf,MAAMF,KAA8B;EAC1C,MAAMkB,YAAY,KAAKJ,MAAMK,IAAInB,GAAG;EAEpC,IAAIkB,WACF,OAAOE,QAAQC,QAAQH,SAAS;EAGlC,MAAMI,UAAU,KAAKT,cAAcM,IAAInB,GAAG;EAC1C,IAAIsB,SACF,OAAOA;EAGT,MAAMC,UAAUxB,UAAUC,GAAG,CAAC,CAACwB,MAAMC,oBAAoB;GACvD,KAAKX,MAAMY,IAAI1B,KAAKyB,eAAe;GACnC,OAAOA;EACT,CAAC;EACD,KAAKZ,cAAca,IAAI1B,KAAKuB,OAAO;EACnC,OAAOA,QAAQI,cAAc;GAC3B,KAAKd,cAAce,OAAO5B,GAAG;EAC/B,CAAC;CACH;CAEQiB,aAAmB;EACzB,IAAI,KAAKD,gBACNnB,WAAqEgC,aAAaC,MAAM;GACvF,MAAMC,OAAOD,EAAEE,MAAM;GACrBD,KAAKE,aAAaC,UAA6C;IAC7D,MAAM,EAAEC,SAASD,MAAME;IAEvB,QAAQD,MAAR;KACE,KAAK,WACH,KAAKE,YAAYH,MAAME,KAAKE,QAAQP,IAAI;IAE5C;GACF;GACAA,KAAKQ,MAAM;EACb;OAEA1C,WAAWoC,aAAaC,UAA6C;GACnE,MAAM,EAAEC,SAASD,MAAME;GAEvB,QAAQD,MAAR;IACE,KAAK,WACH,KAAKE,YAAYH,MAAME,KAAKE,QAAQJ,MAAMF,MAAM,EAAE;GAEtD;EACF;CAEJ;CAEQK,YAAYC,QAAgBP,MAAyB;EAC3D,KAAKpB,QAAQe,IAAIY,QAAQP,IAAI;EAC7BA,KAAKE,aAAaC,UAA6B;GAC7C,IAAIA,MAAMC,SAAS,SAAS;IAC1B,KAAKxB,QAAQiB,OAAOU,MAAM;IAC1B;GACF;GAEA,MAAM,EAAEH,SAASD,MAAME;GACvB,QAAQD,MAAR;IACE,KAAK,QACH,AAAK,KAAKK,QAAQN,MAAME,IAAI;GAEhC;EACF;CACF;CAEA,MAAcI,QAAQN,OAAwC;EAC5D,MAAM,EAAEI,QAAQtC,QAAQkC;EAExB,MAAMhB,YAAY,MAAM,KAAKhB,MAAMF,GAAG;EAEtC+B,AADa,KAAKpB,QAAQQ,IAAImB,MAC9BP,CAAI,CAACU,YAAY;GAAEN,MAAM;GAAoBG;GAAQtC;GAAKkB;EAAU,CAAC;CACvE;AACF"}

package/dist/pagination.d.ts

@@ -0,0 +1,2 @@
+import { InfinitePaginationContentFeatures, InfinitePaginationState, PageCache, PageHints, PagedPaginationContentFeatures, PagedPaginationState, PaginateArgs, PaginateMode, PaginationCache, PaginationContentFeatures, PaginationContentFeaturesFor, PaginationLink, PaginationLinks, PaginationLinksSubscription, PaginationState, PaginationStateFor, PaginationSubscription, PlaceholderPaginationLink, RealPaginationLink, RelationalPaginationLink, SharedPaginationContentFeatures, SharedPaginationState, clearPaginationCache, createPaginationLinksSubscription, createPaginationSubscription, defaultPageHints, getPaginationCache, getPaginationLinks, getPaginationState } from "@warp-drive-mirror/core/signals/-leaked";
+export { type InfinitePaginationContentFeatures, type InfinitePaginationState, type PageCache, type PageHints, type PagedPaginationContentFeatures, type PagedPaginationState, type PaginateArgs, type PaginateMode, type PaginationCache, type PaginationContentFeatures, type PaginationContentFeaturesFor, type PaginationLink, type PaginationLinks, type PaginationLinksSubscription, type PaginationState, type PaginationStateFor, type PaginationSubscription, type PlaceholderPaginationLink, type RealPaginationLink, type RelationalPaginationLink, type SharedPaginationContentFeatures, type SharedPaginationState, clearPaginationCache, createPaginationLinksSubscription, createPaginationSubscription, defaultPageHints, getPaginationCache, getPaginationLinks, getPaginationState };

package/dist/pagination.js

@@ -0,0 +1,3 @@
+import { clearPaginationCache, createPaginationLinksSubscription, createPaginationSubscription, defaultPageHints, getPaginationCache, getPaginationLinks, getPaginationState } from "@warp-drive-mirror/core/signals/-leaked";
+
+export { clearPaginationCache, createPaginationLinksSubscription, createPaginationSubscription, defaultPageHints, getPaginationCache, getPaginationLinks, getPaginationState };