@warp-drive/experiments 0.2.7-alpha.9 → 0.2.7-beta.1

package/dist/unpkg/dev/image-worker.js

@@ -1,99 +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);
-}
-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
-    });
-  }
+	const fileBlob = await (await fetch(url)).blob();
+	return URL.createObjectURL(fileBlob);
 }
+/**
+* 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/unpkg/dev/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":["// eslint-disable-next-line @typescript-eslint/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"}