@loaders.gl/worker-utils 3.1.0-alpha.5 → 3.1.0-beta.4

package/dist/lib/worker-utils/get-loadable-worker-url.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoadableWorkerURL = void 0;
+const assert_1 = require("../env-utils/assert");
+const workerURLCache = new Map();
+/**
+ * Creates a loadable URL from worker source or URL
+ * that can be used to create `Worker` instances.
+ * Due to CORS issues it may be necessary to wrap a URL in a small importScripts
+ * @param props
+ * @param props.source Worker source
+ * @param props.url Worker URL
+ * @returns loadable url
+ */
+function getLoadableWorkerURL(props) {
+    (0, assert_1.assert)((props.source && !props.url) || (!props.source && props.url)); // Either source or url must be defined
+    let workerURL = workerURLCache.get(props.source || props.url);
+    if (!workerURL) {
+        // Differentiate worker urls from worker source code
+        if (props.url) {
+            workerURL = getLoadableWorkerURLFromURL(props.url);
+            workerURLCache.set(props.url, workerURL);
+        }
+        if (props.source) {
+            workerURL = getLoadableWorkerURLFromSource(props.source);
+            workerURLCache.set(props.source, workerURL);
+        }
+    }
+    (0, assert_1.assert)(workerURL);
+    return workerURL;
+}
+exports.getLoadableWorkerURL = getLoadableWorkerURL;
+/**
+ * Build a loadable worker URL from worker URL
+ * @param url
+ * @returns loadable URL
+ */
+function getLoadableWorkerURLFromURL(url) {
+    // A local script url, we can use it to initialize a Worker directly
+    if (!url.startsWith('http')) {
+        return url;
+    }
+    // A remote script, we need to use `importScripts` to load from different origin
+    const workerSource = buildScriptSource(url);
+    return getLoadableWorkerURLFromSource(workerSource);
+}
+/**
+ * Build a loadable worker URL from worker source
+ * @param workerSource
+ * @returns loadable url
+ */
+function getLoadableWorkerURLFromSource(workerSource) {
+    // NOTE: webworkify was previously used
+    // const blob = webworkify(workerSource, {bare: true});
+    const blob = new Blob([workerSource], { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
+}
+/**
+ * Per spec, worker cannot be initialized with a script from a different origin
+ * However a local worker script can still import scripts from other origins,
+ * so we simply build a wrapper script.
+ *
+ * @param workerUrl
+ * @returns source
+ */
+function buildScriptSource(workerUrl) {
+    return `\
+try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+}

package/dist/lib/worker-utils/get-transfer-list.d.ts

@@ -7,3 +7,4 @@
  * @returns a transfer list that can be passed to postMessage
  */
 export declare function getTransferList(object: any, recursive?: boolean, transfers?: Set<any>): Transferable[];
+//# sourceMappingURL=get-transfer-list.d.ts.map

package/dist/lib/worker-utils/get-transfer-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-transfer-list.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-utils/get-transfer-list.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,GAAG,EACX,SAAS,GAAE,OAAc,EACzB,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GACnB,YAAY,EAAE,CAwBhB"}

package/dist/lib/worker-utils/get-transfer-list.js

@@ -0,0 +1,61 @@
+"use strict";
+// NOTE - there is a copy of this function is both in core and loader-utils
+// core does not need all the utils in loader-utils, just this one.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransferList = void 0;
+/**
+ * Returns an array of Transferrable objects that can be used with postMessage
+ * https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage
+ * @param object data to be sent via postMessage
+ * @param recursive - not for application use
+ * @param transfers - not for application use
+ * @returns a transfer list that can be passed to postMessage
+ */
+function getTransferList(object, recursive = true, transfers) {
+    // Make sure that items in the transfer list is unique
+    const transfersSet = transfers || new Set();
+    if (!object) {
+        // ignore
+    }
+    else if (isTransferable(object)) {
+        transfersSet.add(object);
+    }
+    else if (isTransferable(object.buffer)) {
+        // Typed array
+        transfersSet.add(object.buffer);
+    }
+    else if (ArrayBuffer.isView(object)) {
+        // object is a TypeArray viewing into a SharedArrayBuffer (not transferable)
+        // Do not iterate through the content in this case
+    }
+    else if (recursive && typeof object === 'object') {
+        for (const key in object) {
+            // Avoid perf hit - only go one level deep
+            getTransferList(object[key], recursive, transfersSet);
+        }
+    }
+    // If transfers is defined, is internal recursive call
+    // Otherwise it's called by the user
+    return transfers === undefined ? Array.from(transfersSet) : [];
+}
+exports.getTransferList = getTransferList;
+// https://developer.mozilla.org/en-US/docs/Web/API/Transferable
+function isTransferable(object) {
+    if (!object) {
+        return false;
+    }
+    if (object instanceof ArrayBuffer) {
+        return true;
+    }
+    if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {
+        return true;
+    }
+    if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {
+        return true;
+    }
+    // @ts-ignore
+    if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {
+        return true;
+    }
+    return false;
+}

package/dist/lib/worker-utils/remove-nontransferable-options.d.ts

@@ -3,3 +3,4 @@
  * @param value
  */
 export declare function removeNontransferableOptions(object: object): object;
+//# sourceMappingURL=remove-nontransferable-options.d.ts.map

package/dist/lib/worker-utils/remove-nontransferable-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-nontransferable-options.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-utils/remove-nontransferable-options.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKnE"}

package/dist/lib/worker-utils/remove-nontransferable-options.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeNontransferableOptions = void 0;
+/**
+ * Safely stringify JSON (drop non serializable values like functions and regexps)
+ * @param value
+ */
+function removeNontransferableOptions(object) {
+    // options.log object contains functions which cannot be transferred
+    // TODO - decide how to handle logging on workers
+    // TODO - warn if options stringification is long
+    return JSON.parse(stringifyJSON(object));
+}
+exports.removeNontransferableOptions = removeNontransferableOptions;
+function stringifyJSON(v) {
+    const cache = new Set();
+    return JSON.stringify(v, (key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (cache.has(value)) {
+                // Circular reference found
+                try {
+                    // If this value does not reference a parent it can be deduped
+                    return JSON.parse(JSON.stringify(value));
+                }
+                catch (err) {
+                    // discard key if value cannot be deduped
+                    return undefined;
+                }
+            }
+            // Store value in our set
+            cache.add(value);
+        }
+        return value;
+    });
+}