@pyscript/core 0.7.14 → 0.7.16

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pyscript/core",
-    "version": "0.7.14",
+    "version": "0.7.16",
     "type": "module",
     "description": "PyScript",
     "module": "./index.js",
@@ -71,7 +71,7 @@
         "@webreflection/utils": "^0.1.1",
         "add-promise-listener": "^0.1.3",
         "basic-devtools": "^0.1.6",
-        "polyscript": "^0.20.5",
+        "polyscript": "^0.20.8",
         "sticky-module": "^0.1.1",
         "to-json-callback": "^0.1.1",
         "type-checked-collections": "^0.1.7"
@@ -82,7 +82,7 @@
         "@codemirror/language": "^6.12.1",
         "@codemirror/state": "^6.5.4",
         "@codemirror/view": "^6.39.11",
-        "@playwright/test": "^1.57.0",
+        "@playwright/test": "^1.58.0",
         "@rollup/plugin-commonjs": "^29.0.0",
         "@rollup/plugin-node-resolve": "^16.0.3",
         "@rollup/plugin-terser": "^0.4.4",
@@ -90,13 +90,13 @@
         "@xterm/addon-fit": "0.11.0",
         "@xterm/addon-web-links": "0.12.0",
         "@xterm/xterm": "5.5.0",
-        "bun": "^1.3.6",
+        "bun": "^1.3.7",
         "chokidar": "^5.0.0",
         "codedent": "^0.1.2",
         "codemirror": "^6.0.2",
         "eslint": "^9.39.2",
         "flatted": "^3.3.3",
-        "rollup": "^4.55.3",
+        "rollup": "^4.57.0",
         "rollup-plugin-postcss": "^4.0.2",
         "rollup-plugin-string": "^3.0.0",
         "static-handler": "^0.5.3",

package/src/config.js

@@ -9,6 +9,7 @@ import TYPES from "./types.js";
 import allPlugins from "./plugins.js";
 import { robustFetch as fetch, getText } from "./fetch.js";
 import { ErrorCode } from "./exceptions.js";
+import { toml as tomlParser } from "polyscript/exports";
 
 const { BAD_CONFIG, CONFLICTING_CODE } = ErrorCode;
 
@@ -43,6 +44,11 @@ export const configDetails = async (config, type) => {
     return { json, toml: toml || (!json && !!text), text, url };
 };
 
+const configParser = pyElement => {
+    const parser = pyElement.getAttribute("config-parser");
+    return parser ? new URL(parser, location.href).href : undefined;
+};
+
 const conflictError = (reason) => new Error(`(${CONFLICTING_CODE}): ${reason}`);
 
 const relative_url = (url, base = location.href) => new URL(url, base).href;
@@ -93,11 +99,11 @@ for (const [TYPE] of TYPES) {
             [pyElement] = pyConfigs;
             config = pyElement.getAttribute("src") || pyElement.textContent;
             type = pyElement.getAttribute("type");
-            parser = pyElement.getAttribute("config-parser");
+            parser = configParser(pyElement);
         } else if (attrConfigs.length) {
             [pyElement, ...attrConfigs] = attrConfigs;
             config = pyElement.getAttribute("config");
-            parser = pyElement.getAttribute("config-parser");
+            parser = configParser(pyElement);
             // throw an error if dirrent scripts use different configs
             if (
                 attrConfigs.some((el) => el.getAttribute("config") !== config)
@@ -125,11 +131,8 @@ for (const [TYPE] of TYPES) {
                 try {
                     const module = parser
                         ? await import(parser)
-                        : await import(
-                              /* webpackIgnore: true */ "./3rd-party/toml.js"
-                          );
-                    const parse = module.parse || module.default;
-                    parsed = parse(text);
+                        : await tomlParser(text).then(json => ({ parse: () => json }));
+                    parsed = (module.parse || module.default)(text);
                 } catch (e) {
                     error = syntaxError("TOML", url, e);
                 }
@@ -163,7 +166,7 @@ for (const [TYPE] of TYPES) {
     if (Number.isSafeInteger(parsed?.experimental_ffi_timeout))
         globalThis.reflected_ffi_timeout = parsed?.experimental_ffi_timeout;
 
-    configs.set(TYPE, { config: parsed, configURL, plugins, error });
+    configs.set(TYPE, { config: parsed, configURL, parser, plugins, error });
 }
 
 export { configs, relative_url };

package/src/core.js

@@ -117,7 +117,7 @@ for (const [TYPE, interpreter] of TYPES) {
         else dispatch(element, TYPE, "done");
     };
 
-    let { config, configURL, plugins, error } = configs.get(TYPE);
+    let { config, configURL, parser, plugins, error } = configs.get(TYPE);
 
     // create a unique identifier when/if needed
     let id = 0;
@@ -180,201 +180,190 @@ for (const [TYPE, interpreter] of TYPES) {
         });
     };
 
-    // define the module as both `<script type="py">` and `<py-script>`
-    // but only if the config didn't throw an error
-    if (!error) {
-        // ensure plugins are bootstrapped already before custom type definition
-        // NOTE: we cannot top-level await in here as plugins import other utilities
-        //       from core.js itself so that custom definition should not be blocking.
-        plugins().then(() => {
-            // possible early errors sent by polyscript
-            const errors = new Map();
-
-            // specific main and worker hooks
-            const hooks = {
-                main: {
-                    ...codeFor(main, TYPE),
-                    async onReady(wrap, element) {
-                        registerModule(wrap);
-
-                        // allows plugins to do whatever they want with the element
-                        // before regular stuff happens in here
-                        for (const callback of main("onReady"))
-                            await callback(wrap, element);
-
-                        // now that all possible plugins are configured,
-                        // bail out if polyscript encountered an error
-                        if (errors.has(element)) {
-                            let { message } = errors.get(element);
-                            errors.delete(element);
-                            const clone = message === INVALID_CONTENT;
-                            message = `(${ErrorCode.CONFLICTING_CODE}) ${message} for `;
-                            message += element.cloneNode(clone).outerHTML;
-                            wrap.io.stderr(message);
-                            return;
-                        }
+    // ensure plugins are bootstrapped already before custom type definition
+    // NOTE: we cannot top-level await in here as plugins import other utilities
+    //       from core.js itself so that custom definition should not be blocking.
+    plugins().then(() => {
+        // let plugins logic decide how to show the error but stop here if any
+        if (error) return;
+
+        // possible early errors sent by polyscript
+        const errors = new Map();
+
+        // specific main and worker hooks
+        const hooks = {
+            main: {
+                ...codeFor(main, TYPE),
+                async onReady(wrap, element) {
+                    registerModule(wrap);
+
+                    // allows plugins to do whatever they want with the element
+                    // before regular stuff happens in here
+                    for (const callback of main("onReady"))
+                        await callback(wrap, element);
+
+                    // now that all possible plugins are configured,
+                    // bail out if polyscript encountered an error
+                    if (errors.has(element)) {
+                        let { message } = errors.get(element);
+                        errors.delete(element);
+                        const clone = message === INVALID_CONTENT;
+                        message = `(${ErrorCode.CONFLICTING_CODE}) ${message} for `;
+                        message += element.cloneNode(clone).outerHTML;
+                        wrap.io.stderr(message);
+                        return;
+                    }
 
-                        if (isScript(element)) {
-                            const isAsync = !isSync(element);
-                            const target = element.getAttribute("target");
-                            const show = target
-                                ? queryTarget(element, target)
-                                : document.createElement("script-py");
-
-                            if (!target) {
-                                const { head, body } = document;
-                                if (head.contains(element)) body.append(show);
-                                else element.after(show);
-                            }
-                            if (!show.id) show.id = getID();
-
-                            // allows the code to retrieve the target element via
-                            // document.currentScript.target if needed
-                            defineProperty(element, "target", { value: show });
-
-                            // notify before the code runs
-                            dispatch(element, TYPE, "ready");
-                            dispatchDone(
-                                element,
-                                isAsync,
-                                wrap[`run${isAsync ? "Async" : ""}`](
-                                    await fetchSource(element, wrap.io, true),
-                                ),
-                            );
-                        } else {
-                            // resolve PyScriptElement to allow connectedCallback
-                            element._wrap.resolve(wrap);
+                    if (isScript(element)) {
+                        const isAsync = !isSync(element);
+                        const target = element.getAttribute("target");
+                        const show = target
+                            ? queryTarget(element, target)
+                            : document.createElement("script-py");
+
+                        if (!target) {
+                            const { head, body } = document;
+                            if (head.contains(element)) body.append(show);
+                            else element.after(show);
                         }
-                        console.debug("[pyscript/main] PyScript Ready");
-                    },
-                    onWorker(_, xworker) {
-                        assign(xworker.sync, sync);
-                        for (const callback of main("onWorker"))
-                            callback(_, xworker);
-                    },
-                    onBeforeRun(wrap, element) {
-                        currentElement = element;
-                        bootstrapNodeAndPlugins(
-                            main,
-                            wrap,
-                            element,
-                            "onBeforeRun",
-                        );
-                    },
-                    onBeforeRunAsync(wrap, element) {
-                        currentElement = element;
-                        return bootstrapNodeAndPlugins(
-                            main,
-                            wrap,
-                            element,
-                            "onBeforeRunAsync",
-                        );
-                    },
-                    onAfterRun(wrap, element) {
-                        bootstrapNodeAndPlugins(
-                            main,
-                            wrap,
-                            element,
-                            "onAfterRun",
-                        );
-                    },
-                    onAfterRunAsync(wrap, element) {
-                        return bootstrapNodeAndPlugins(
-                            main,
-                            wrap,
+                        if (!show.id) show.id = getID();
+
+                        // allows the code to retrieve the target element via
+                        // document.currentScript.target if needed
+                        defineProperty(element, "target", { value: show });
+
+                        // notify before the code runs
+                        dispatch(element, TYPE, "ready");
+                        dispatchDone(
                             element,
-                            "onAfterRunAsync",
+                            isAsync,
+                            wrap[`run${isAsync ? "Async" : ""}`](
+                                await fetchSource(element, wrap.io, true),
+                            ),
                         );
-                    },
+                    } else {
+                        // resolve PyScriptElement to allow connectedCallback
+                        element._wrap.resolve(wrap);
+                    }
+                    console.debug("[pyscript/main] PyScript Ready");
                 },
-                worker: {
-                    ...codeFor(worker, TYPE),
-                    // these are lazy getters that returns a composition
-                    // of the current hooks or undefined, if no hook is present
-                    get onReady() {
-                        return createFunction(this, "onReady", true);
-                    },
-                    get onBeforeRun() {
-                        return createFunction(this, "onBeforeRun", false);
-                    },
-                    get onBeforeRunAsync() {
-                        return createFunction(this, "onBeforeRunAsync", true);
-                    },
-                    get onAfterRun() {
-                        return createFunction(this, "onAfterRun", false);
-                    },
-                    get onAfterRunAsync() {
-                        return createFunction(this, "onAfterRunAsync", true);
-                    },
+                onWorker(_, xworker) {
+                    assign(xworker.sync, sync);
+                    for (const callback of main("onWorker"))
+                        callback(_, xworker);
                 },
-            };
-
-            hooked.set(TYPE, hooks);
-
-            // allow offline interpreter detection via [offline] attribute
-            let version = offline_interpreter(config);
-            if (!version) {
-                const css = "script[type='module'][offline]";
-                const s = document.querySelector(css)?.src;
-                if (s && import.meta.url.startsWith(s.replace(/\.js$/, ""))) {
-                    version = `./pyscript/${interpreter}/${interpreter}.mjs`;
-                    version = offline_interpreter({ interpreter: version });
-                }
-            }
-
-            define(TYPE, {
-                config,
-                configURL,
-                interpreter,
-                hooks,
-                version,
-                env: `${TYPE}-script`,
-                onerror(error, element) {
-                    errors.set(element, error);
+                onBeforeRun(wrap, element) {
+                    currentElement = element;
+                    bootstrapNodeAndPlugins(main, wrap, element, "onBeforeRun");
                 },
-            });
-
-            customElements.define(
-                `${TYPE}-script`,
-                class extends HTMLElement {
-                    constructor() {
-                        assign(super(), {
-                            _wrap: withResolvers(),
-                            srcCode: "",
-                            executed: false,
-                        });
-                    }
-                    get id() {
-                        return super.id || (super.id = getID());
-                    }
-                    set id(value) {
-                        super.id = value;
-                    }
-                    async connectedCallback() {
-                        if (!this.executed) {
-                            this.executed = true;
-                            const isAsync = !isSync(this);
-                            const { io, run, runAsync } = await this._wrap
-                                .promise;
-                            this.srcCode = await fetchSource(
-                                this,
-                                io,
-                                !this.childElementCount,
-                            );
-                            this.replaceChildren();
-                            this.style.display = "block";
-                            dispatch(this, TYPE, "ready");
-                            dispatchDone(
-                                this,
-                                isAsync,
-                                (isAsync ? runAsync : run)(this.srcCode),
-                            );
-                        }
-                    }
+                onBeforeRunAsync(wrap, element) {
+                    currentElement = element;
+                    return bootstrapNodeAndPlugins(
+                        main,
+                        wrap,
+                        element,
+                        "onBeforeRunAsync",
+                    );
                 },
-            );
+                onAfterRun(wrap, element) {
+                    bootstrapNodeAndPlugins(main, wrap, element, "onAfterRun");
+                },
+                onAfterRunAsync(wrap, element) {
+                    return bootstrapNodeAndPlugins(
+                        main,
+                        wrap,
+                        element,
+                        "onAfterRunAsync",
+                    );
+                },
+            },
+            worker: {
+                ...codeFor(worker, TYPE),
+                // these are lazy getters that returns a composition
+                // of the current hooks or undefined, if no hook is present
+                get onReady() {
+                    return createFunction(this, "onReady", true);
+                },
+                get onBeforeRun() {
+                    return createFunction(this, "onBeforeRun", false);
+                },
+                get onBeforeRunAsync() {
+                    return createFunction(this, "onBeforeRunAsync", true);
+                },
+                get onAfterRun() {
+                    return createFunction(this, "onAfterRun", false);
+                },
+                get onAfterRunAsync() {
+                    return createFunction(this, "onAfterRunAsync", true);
+                },
+            },
+        };
+
+        hooked.set(TYPE, hooks);
+
+        // allow offline interpreter detection via [offline] attribute
+        let version = offline_interpreter(config);
+        if (!version) {
+            const css = "script[type='module'][offline]";
+            const s = document.querySelector(css)?.src;
+            if (s && import.meta.url.startsWith(s.replace(/\.js$/, ""))) {
+                version = `./pyscript/${interpreter}/${interpreter}.mjs`;
+                version = offline_interpreter({ interpreter: version });
+            }
+        }
+
+        define(TYPE, {
+            config,
+            configURL,
+            interpreter,
+            hooks,
+            version,
+            env: `${TYPE}-script`,
+            parser: parser && new URL(parser, location.href).href,
+            onerror(error, element) {
+                errors.set(element, error);
+            },
         });
-    }
+
+        customElements.define(
+            `${TYPE}-script`,
+            class extends HTMLElement {
+                constructor() {
+                    assign(super(), {
+                        _wrap: withResolvers(),
+                        srcCode: "",
+                        executed: false,
+                    });
+                }
+                get id() {
+                    return super.id || (super.id = getID());
+                }
+                set id(value) {
+                    super.id = value;
+                }
+                async connectedCallback() {
+                    if (!this.executed) {
+                        this.executed = true;
+                        const isAsync = !isSync(this);
+                        const { io, run, runAsync } = await this._wrap.promise;
+                        this.srcCode = await fetchSource(
+                            this,
+                            io,
+                            !this.childElementCount,
+                        );
+                        this.replaceChildren();
+                        this.style.display = "block";
+                        dispatch(this, TYPE, "ready");
+                        dispatchDone(
+                            this,
+                            isAsync,
+                            (isAsync ? runAsync : run)(this.srcCode),
+                        );
+                    }
+                }
+            },
+        );
+    });
 
     // export the used config without allowing leaks through it
     exportedConfig[TYPE] = structuredClone(config);