@pyscript/core 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pyscript/core",
-    "version": "0.2.1",
+    "version": "0.2.2",
     "type": "module",
     "description": "PyScript",
     "module": "./index.js",

package/src/config.js

@@ -5,6 +5,7 @@
  */
 import { $ } from "basic-devtools";
 
+import TYPES from "./types.js";
 import allPlugins from "./plugins.js";
 import { robustFetch as fetch, getText } from "./fetch.js";
 import { ErrorCode } from "./exceptions.js";
@@ -45,66 +46,72 @@ const syntaxError = (type, url, { message }) => {
     return new SyntaxError(`${str}\n${message}`);
 };
 
-// find the shared config for all py-script elements
-let config, plugins, parsed, error, type;
-let pyConfig = $("py-config");
-if (pyConfig) {
-    config = pyConfig.getAttribute("src") || pyConfig.textContent;
-    type = pyConfig.getAttribute("type");
-} else {
-    pyConfig = $(
-        [
-            'script[type="py"][config]:not([worker])',
-            "py-script[config]:not([worker])",
-        ].join(","),
-    );
-    if (pyConfig) config = pyConfig.getAttribute("config");
-}
+const configs = new Map();
 
-// catch possible fetch errors
-if (config) {
-    try {
-        const { json, toml, text, url } = await configDetails(config);
-        config = text;
-        if (json || type === "json") {
-            try {
-                parsed = JSON.parse(text);
-            } catch (e) {
-                error = syntaxError("JSON", url, e);
-            }
-        } else if (toml || type === "toml") {
-            try {
-                const { parse } = await import(
-                    /* webpackIgnore: true */
-                    "https://cdn.jsdelivr.net/npm/@webreflection/toml-j0.4/toml.js"
-                );
-                parsed = parse(text);
-            } catch (e) {
-                error = syntaxError("TOML", url, e);
+for (const [TYPE] of TYPES) {
+    // find the shared config for all py-script elements
+    let config, plugins, parsed, error, type;
+    let pyConfig = $(`${TYPE}-config`);
+    if (pyConfig) {
+        config = pyConfig.getAttribute("src") || pyConfig.textContent;
+        type = pyConfig.getAttribute("type");
+    } else {
+        pyConfig = $(
+            [
+                `script[type="${TYPE}"][config]:not([worker])`,
+                `${TYPE}-script[config]:not([worker])`,
+            ].join(","),
+        );
+        if (pyConfig) config = pyConfig.getAttribute("config");
+    }
+
+    // catch possible fetch errors
+    if (config) {
+        try {
+            const { json, toml, text, url } = await configDetails(config);
+            config = text;
+            if (json || type === "json") {
+                try {
+                    parsed = JSON.parse(text);
+                } catch (e) {
+                    error = syntaxError("JSON", url, e);
+                }
+            } else if (toml || type === "toml") {
+                try {
+                    const { parse } = await import(
+                        /* webpackIgnore: true */
+                        "https://cdn.jsdelivr.net/npm/@webreflection/toml-j0.4/toml.js"
+                    );
+                    parsed = parse(text);
+                } catch (e) {
+                    error = syntaxError("TOML", url, e);
+                }
             }
+        } catch (e) {
+            error = e;
         }
-    } catch (e) {
-        error = e;
     }
-}
 
-// parse all plugins and optionally ignore only
-// those flagged as "undesired" via `!` prefix
-const toBeAwaited = [];
-for (const [key, value] of Object.entries(allPlugins)) {
-    if (error) {
-        if (key === "error") {
-            // show on page the config is broken, meaning that
-            // it was not possible to disable error plugin neither
-            // as that part wasn't correctly parsed anyway
-            value().then(({ notify }) => notify(error.message));
+    // parse all plugins and optionally ignore only
+    // those flagged as "undesired" via `!` prefix
+    const toBeAwaited = [];
+    for (const [key, value] of Object.entries(allPlugins)) {
+        if (error) {
+            if (key === "error") {
+                // show on page the config is broken, meaning that
+                // it was not possible to disable error plugin neither
+                // as that part wasn't correctly parsed anyway
+                value().then(({ notify }) => notify(error.message));
+            }
+        } else if (!parsed?.plugins?.includes(`!${key}`)) {
+            toBeAwaited.push(value());
         }
-    } else if (!parsed?.plugins?.includes(`!${key}`)) {
-        toBeAwaited.push(value());
     }
-}
 
-// assign plugins as Promise.all only if needed
-if (toBeAwaited.length) plugins = Promise.all(toBeAwaited);
+    // assign plugins as Promise.all only if needed
+    if (toBeAwaited.length) plugins = Promise.all(toBeAwaited);
+
+    configs.set(TYPE, { config: parsed, plugins, error });
+}
 
-export { parsed as config, plugins, error };
+export default configs;

package/src/core.js

@@ -9,10 +9,11 @@ import { queryTarget } from "../node_modules/polyscript/esm/script-handler.js";
 import { dedent, dispatch } from "../node_modules/polyscript/esm/utils.js";
 import { Hook } from "../node_modules/polyscript/esm/worker/hooks.js";
 
-import { ErrorCode } from "./exceptions.js";
+import TYPES from "./types.js";
+import configs from "./config.js";
 import sync from "./sync.js";
 import stdlib from "./stdlib.js";
-import { config, plugins, error } from "./config.js";
+import { ErrorCode } from "./exceptions.js";
 import { robustFetch as fetch, getText } from "./fetch.js";
 
 const { assign, defineProperty } = Object;
@@ -20,11 +21,6 @@ const { assign, defineProperty } = Object;
 // allows lazy element features on code evaluation
 let currentElement;
 
-const TYPES = new Map([
-    ["py", "pyodide"],
-    ["mpy", "micropython"],
-]);
-
 // generic helper to disambiguate between custom element and script
 const isScript = ({ tagName }) => tagName === "SCRIPT";
 
@@ -103,7 +99,12 @@ const workerHooks = {
         [...hooks.codeAfterRunWorkerAsync].map(dedent).join("\n"),
 };
 
+const exportedConfig = {};
+export { exportedConfig as config };
+
 for (const [TYPE, interpreter] of TYPES) {
+    const { config, plugins, error } = configs.get(TYPE);
+
     // create a unique identifier when/if needed
     let id = 0;
     const getID = (prefix = TYPE) => `${prefix}-${id++}`;
@@ -273,6 +274,9 @@ for (const [TYPE, interpreter] of TYPES) {
 
     // define py-script only if the config didn't throw an error
     if (!error) customElements.define(`${TYPE}-script`, PyScriptElement);
+
+    // export the used config without allowing leaks through it
+    exportedConfig[TYPE] = structuredClone(config);
 }
 
 // TBD: I think manual worker cases are interesting in pyodide only

package/src/types.js

@@ -0,0 +1,4 @@
+export default new Map([
+    ["py", "pyodide"],
+    ["mpy", "micropython"],
+]);

package/types/config.d.ts

@@ -1,4 +1,2 @@
-declare let parsed: any;
-export let plugins: any;
-export let error: any;
-export { parsed as config };
+export default configs;
+declare const configs: Map<any, any>;

package/types/core.d.ts

@@ -21,5 +21,6 @@ export namespace hooks {
     let codeAfterRunWorker: Set<string>;
     let codeAfterRunWorkerAsync: Set<string>;
 }
-import { config } from "./config.js";
+export { exportedConfig as config };
 import sync from "./sync.js";
+declare const exportedConfig: {};

package/types/types.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Map<string, string>;
+export default _default;