Updating coincident to its latest

Author: WebReflection

cjs/package.json

@@ -110,16 +110,20 @@ export const importJS = (source, name) => import(source).then(esm => {
 });
 
 export const importCSS = href => new Promise((onload, onerror) => {
-    if (document.querySelector(`link[href="${href}"]`)) onload();
-    document.head.append(
-        assign(
-            document.createElement('link'),
-            { rel: 'stylesheet', href, onload, onerror },
-        )
-    )
+    if (document.querySelector(`link[rel="stylesheet"][href="${href}"]`)) {
+        onload();
+    }
+    else {
+        document.head.append(
+            assign(
+                document.createElement('link'),
+                { rel: 'stylesheet', href, onload, onerror },
+            )
+        );
+    }
 });
 
-export const isCSS = source => /\.css/i.test(new URL(source).pathname);
+export const isCSS = source => /\.css$/i.test(new URL(source).pathname);
 /* c8 ignore stop */
 
 export {

docs/index.js

@@ -5,7 +5,7 @@
 //    bigger than it used to be before any changes is applied to this file.
 
 import * as JSON from '@ungap/structured-clone/json';
-import coincident from 'coincident/window';
+import coincident from 'coincident/window/worker';
 
 import { assign, create, createFunction, createOverload, createResolved, dispatch, registerJSModules } from '../utils.js';
 import createJSModules from './js_modules.js';
@@ -32,19 +32,23 @@ const add = (type, fn) => {
 
 const { parse, stringify } = JSON;
 
-const { proxy: sync, window, isWindowProxy } = coincident(self, {
+const { proxy: sync, sync: syncMainAndWorker, polyfill, window, isWindowProxy } = await coincident({
     parse,
     stringify,
     transform: value => transform ? transform(value) : value
 });
 
 const xworker = {
+    // propagate the fact SharedArrayBuffer is polyfilled
+    polyfill,
     // allows synchronous utilities between this worker and the main thread
     sync,
     // allow access to the main thread world
     window,
     // allow introspection for foreign (main thread) refrences
     isWindowProxy,
+    // propagate the fact `window` can be used
+    hasWindow: syncMainAndWorker,
     // standard worker related events / features
     onmessage: console.info,
     onerror: console.error,
@@ -61,38 +65,10 @@ add('message', ({ data: { options, config: baseURL, configURL, code, hooks } })
 
             const interpreter = await getRuntime(runtimeID, baseURL, configURL, config);
 
-            const { js_modules, sync_main_only } = configs.get(runtimeID);
+            const { js_modules } = configs.get(runtimeID);
 
             const mainModules = js_modules?.main;
 
-            // this flag allows interacting with the xworker.sync exposed
-            // *only in the worker* and eventually invoked *only from main*.
-            // If that flag is `false` or not present, then SharedArrayBuffer
-            // must be available or not much can work in here.
-            let syncMainAndWorker = !sync_main_only;
-
-            // bails out out of the box with a native/meaningful error
-            // in case the SharedArrayBuffer is not available
-            try {
-                new SharedArrayBuffer(4);
-                // if this does not throw there's no reason to
-                // branch out of all the features ... but ...
-                syncMainAndWorker = true;
-            }
-            // eslint-disable-next-line no-unused-vars
-            catch (_) {
-                // if it does throw and `sync_main_only` was not `true`
-                // then there's no way to go further
-                if (syncMainAndWorker) {
-                    throw new Error(
-                        [
-                            'Unable to use SharedArrayBuffer due insecure environment.',
-                            'Please read requirements in MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements',
-                        ].join('\n'),
-                    );
-                }
-            }
-
             const details = create(registry.get(type));
 
             const resolved = createResolved(

docs/index.js.map

@@ -1,6 +1,4 @@
-import * as JSON from '@ungap/structured-clone/json';
 import fetch from '@webreflection/fetch';
-import coincident from 'coincident/window';
 import xworker from './xworker.js';
 import { getConfigURLAndType } from '../loader.js';
 import { assign, create, defineProperties, importCSS, importJS } from '../utils.js';
@@ -14,6 +12,8 @@ import Hook from './hook.js';
  * @prop {string} [configURL] the optional configURL used to resolve config entries
  */
 
+// REQUIRES INTEGRATION TEST
+/* c8 ignore start */
 export default (...args) =>
     /**
      * A XWorker is a Worker facade able to bootstrap a channel with any desired interpreter.
@@ -22,7 +22,8 @@ export default (...args) =>
      * @returns {Worker}
      */
     function XWorker(url, options) {
-        const worker = xworker();
+        const serviceWorker = options?.serviceWorker;
+        const worker = xworker({ serviceWorker });
         const { postMessage } = worker;
         const isHook = this instanceof Hook;
 
@@ -37,28 +38,31 @@ export default (...args) =>
         // fallback to a generic, ignored, config.txt file to still provide a URL.
         const [ config ] = getConfigURLAndType(options.config, options.configURL);
 
-        const bootstrap = fetch(url)
-            .text()
-            .then(code => {
-                const hooks = isHook ? this.toJSON() : void 0;
-                postMessage.call(worker, { options, config, code, hooks });
-            });
-
         const sync = assign(
-            coincident(worker, JSON).proxy,
+            worker.proxy,
             { importJS, importCSS },
         );
 
         const resolver = Promise.withResolvers();
 
+        let bootstrap = fetch(url)
+            .text()
+            .then(code => {
+                const hooks = isHook ? this.toJSON() : void 0;
+                postMessage.call(worker, { options, config, code, hooks });
+            })
+            .then(() => {
+                // boost postMessage performance
+                bootstrap = { then: fn => fn() };
+            });
+
         defineProperties(worker, {
             sync: { value: sync },
             ready: { value: resolver.promise },
             postMessage: {
-                value: (data, ...rest) =>
-                    bootstrap.then(() =>
-                        postMessage.call(worker, data, ...rest),
-                    ),
+                value: (data, ...rest) => bootstrap.then(
+                    () => postMessage.call(worker, data, ...rest),
+                ),
             },
             onerror: {
                 writable: true,
@@ -87,3 +91,5 @@ export default (...args) =>
 
         return worker;
     };
+
+/* c8 ignore stop */