@pyscript/core 0.2.10 → 0.3.0

package/dist/error-96hMSEw8.js

@@ -0,0 +1,2 @@
+import{hooks as e}from"./core.js";function o(e){const o=document.createElement("div");o.className="py-error",o.textContent=e,o.style.cssText="\n    border: 1px solid red;\n    background: #ffdddd;\n    color: black;\n    font-family: courier, monospace;\n    white-space: pre;\n    overflow-x: auto;\n    padding: 8px;\n    margin-top: 8px;\n  ",document.body.append(o)}e.main.onReady.add((function n(r){e.main.onReady.delete(n);const{stderr:t}=r.io;r.io.stderr=(e,...n)=>(o(e.message||e),t(e,...n)),addEventListener("error",(({message:e})=>{e.startsWith("Uncaught PythonError")&&o(e)}))}));export{o as notify};
+//# sourceMappingURL=error-96hMSEw8.js.map

package/dist/error-96hMSEw8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-96hMSEw8.js","sources":["../src/plugins/error.js"],"sourcesContent":["// PyScript Error Plugin\nimport { hooks } from \"../core.js\";\n\nhooks.main.onReady.add(function override(pyScript) {\n    // be sure this override happens only once\n    hooks.main.onReady.delete(override);\n\n    // trap generic `stderr` to propagate to it regardless\n    const { stderr } = pyScript.io;\n\n    // override it with our own logic\n    pyScript.io.stderr = (error, ...rest) => {\n        notify(error.message || error);\n        // let other plugins or stderr hook, if any, do the rest\n        return stderr(error, ...rest);\n    };\n\n    // be sure uncaught Python errors are also visible\n    addEventListener(\"error\", ({ message }) => {\n        if (message.startsWith(\"Uncaught PythonError\")) notify(message);\n    });\n});\n\n// Error hook utilities\n\n// Custom function to show notifications\n\n/**\n * Add a banner to the top of the page, notifying the user of an error\n * @param {string} message\n */\nexport function notify(message) {\n    const div = document.createElement(\"div\");\n    div.className = \"py-error\";\n    div.textContent = message;\n    div.style.cssText = `\n    border: 1px solid red;\n    background: #ffdddd;\n    color: black;\n    font-family: courier, monospace;\n    white-space: pre;\n    overflow-x: auto;\n    padding: 8px;\n    margin-top: 8px;\n  `;\n    document.body.append(div);\n}\n"],"names":["notify","message","div","document","createElement","className","textContent","style","cssText","body","append","hooks","main","onReady","add","override","pyScript","delete","stderr","io","error","rest","addEventListener","startsWith"],"mappings":"kCA+BO,SAASA,EAAOC,GACnB,MAAMC,EAAMC,SAASC,cAAc,OACnCF,EAAIG,UAAY,WAChBH,EAAII,YAAcL,EAClBC,EAAIK,MAAMC,QAAU,6MAUpBL,SAASM,KAAKC,OAAOR,EACzB,CA3CAS,EAAMC,KAAKC,QAAQC,KAAI,SAASC,EAASC,GAErCL,EAAMC,KAAKC,QAAQI,OAAOF,GAG1B,MAAMG,OAAEA,GAAWF,EAASG,GAG5BH,EAASG,GAAGD,OAAS,CAACE,KAAUC,KAC5BrB,EAAOoB,EAAMnB,SAAWmB,GAEjBF,EAAOE,KAAUC,IAI5BC,iBAAiB,SAAS,EAAGrB,cACrBA,EAAQsB,WAAW,yBAAyBvB,EAAOC,EAAQ,GAEvE"}

package/docs/README.md

@@ -159,7 +159,7 @@ The commonly shared utilities are:
   * **display** in both main and worker, refers to the good old `display` utility except:
     * in the *main* it automatically uses the current script `target` to display content
     * in the *worker* it still needs to know *where* to display content using the `target="dom-id"` named argument, as workers don't get a default target attached
-    * in both main and worker, the `append=False` is the *default* behavior, which is a breaking change compared to classic PyScript, but because there is no `Element` with its `write(content)` utility, which would have used that `append=False` behind the scene, we've decided that `false` as append default is more desired, specially after porting most examples in *PyScript Next*, where `append=True` is the exception, not the norm.
+    * in both main and worker, the `append=True` is the *default* behavior, which is inherited from the classic PyScript.
 
 #### Extra main-only features
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pyscript/core",
-    "version": "0.2.10",
+    "version": "0.3.0",
     "type": "module",
     "description": "PyScript",
     "module": "./index.js",
@@ -20,9 +20,16 @@
     },
     "scripts": {
         "server": "npx static-handler --coi .",
-        "build": "node rollup/toml.cjs && node rollup/stdlib.cjs && node rollup/plugins.cjs && rm -rf dist && rollup --config rollup/core.config.js && eslint src/ && npm run ts",
+        "build": "npm run build:toml && npm run build:stdlib && npm run build:plugins && npm run build:core && eslint src/ && npm run ts",
+        "build:core": "rm -rf dist && rollup --config rollup/core.config.js",
+        "build:plugins": "node rollup/plugins.cjs",
+        "build:stdlib": "node rollup/stdlib.cjs",
+        "build:toml": "node rollup/toml.cjs",
+        "dev": "node dev.cjs",
+        "release": "npm run build && npm run zip",
         "size": "echo -e \"\\033[1mdist/*.js file size\\033[0m\"; for js in $(ls dist/*.js); do echo -e \"\\033[2m$js:\\033[0m $(cat $js | brotli | wc -c) bytes\"; done",
-        "ts": "tsc -p ."
+        "ts": "tsc -p .",
+        "zip": "zip -r dist.zip ./dist"
     },
     "keywords": [
         "pyscript",
@@ -33,15 +40,17 @@
     "dependencies": {
         "@ungap/with-resolvers": "^0.1.0",
         "basic-devtools": "^0.1.6",
-        "polyscript": "^0.4.20",
+        "polyscript": "^0.5.1",
         "sticky-module": "^0.1.0",
+        "to-json-callback": "^0.1.1",
         "type-checked-collections": "^0.1.7"
     },
     "devDependencies": {
         "@rollup/plugin-node-resolve": "^15.2.3",
         "@rollup/plugin-terser": "^0.4.4",
         "@webreflection/toml-j0.4": "^1.1.3",
-        "eslint": "^8.51.0",
+        "chokidar": "^3.5.3",
+        "eslint": "^8.52.0",
         "rollup": "^4.1.4",
         "rollup-plugin-postcss": "^4.0.2",
         "rollup-plugin-string": "^3.0.0",

package/src/core.js

@@ -14,16 +14,18 @@ import {
     dispatch,
     queryTarget,
     unescape,
+    whenDefined,
 } from "polyscript/exports";
 
 import "./all-done.js";
 import TYPES from "./types.js";
 import configs from "./config.js";
-import hooks from "./hooks.js";
 import sync from "./sync.js";
 import stdlib from "./stdlib.js";
+import bootstrapNodeAndPlugins from "./plugins-helper.js";
 import { ErrorCode } from "./exceptions.js";
 import { robustFetch as fetch, getText } from "./fetch.js";
+import { hooks, main, worker, codeFor, createFunction } from "./hooks.js";
 
 // allows lazy element features on code evaluation
 let currentElement;
@@ -31,25 +33,6 @@ let currentElement;
 // generic helper to disambiguate between custom element and script
 const isScript = ({ tagName }) => tagName === "SCRIPT";
 
-// helper for all script[type="py"] out there
-const before = (script) => {
-    defineProperty(document, "currentScript", {
-        configurable: true,
-        get: () => script,
-    });
-};
-
-const after = () => {
-    delete document.currentScript;
-};
-
-// common life-cycle handlers for any node
-const bootstrapNodeAndPlugins = (wrap, element, callback, hook) => {
-    // make it possible to reach the current target node via Python
-    callback(element);
-    for (const fn of hooks[hook]) fn(wrap, element);
-};
-
 let shouldRegister = true;
 const registerModule = ({ XWorker: $XWorker, interpreter, io }) => {
     // automatically use the pyscript stderr (when/if defined)
@@ -73,33 +56,31 @@ const registerModule = ({ XWorker: $XWorker, interpreter, io }) => {
     interpreter.runPython(stdlib, { globals: interpreter.runPython("{}") });
 };
 
-const workerHooks = {
-    codeBeforeRunWorker: () =>
-        [stdlib, ...hooks.codeBeforeRunWorker].map(dedent).join("\n"),
-    codeBeforeRunWorkerAsync: () =>
-        [stdlib, ...hooks.codeBeforeRunWorkerAsync].map(dedent).join("\n"),
-    codeAfterRunWorker: () =>
-        [...hooks.codeAfterRunWorker].map(dedent).join("\n"),
-    codeAfterRunWorkerAsync: () =>
-        [...hooks.codeAfterRunWorkerAsync].map(dedent).join("\n"),
-};
-
 // avoid multiple initialization of the same library
 const [
     {
         PyWorker: exportedPyWorker,
         hooks: exportedHooks,
         config: exportedConfig,
+        whenDefined: exportedWhenDefined,
     },
     alreadyLive,
-] = stickyModule("@pyscript/core", { PyWorker, hooks, config: {} });
+] = stickyModule("@pyscript/core", {
+    PyWorker,
+    hooks,
+    config: {},
+    whenDefined,
+});
 
 export {
     exportedPyWorker as PyWorker,
     exportedHooks as hooks,
     exportedConfig as config,
+    exportedWhenDefined as whenDefined,
 };
 
+const hooked = new Map();
+
 for (const [TYPE, interpreter] of TYPES) {
     // avoid any dance if the module already landed
     if (alreadyLive) break;
@@ -149,107 +130,141 @@ for (const [TYPE, interpreter] of TYPES) {
             // possible early errors sent by polyscript
             const errors = new Map();
 
+            // specific main and worker hooks
+            const hooks = {
+                main: {
+                    ...codeFor(main),
+                    async onReady(wrap, element) {
+                        if (shouldRegister) {
+                            shouldRegister = false;
+                            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 {
+                                attributes: { async: isAsync, target },
+                            } = element;
+                            const hasTarget = !!target?.value;
+                            const show = hasTarget
+                                ? queryTarget(element, target.value)
+                                : document.createElement("script-py");
+
+                            if (!hasTarget) {
+                                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);
+                        }
+                        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,
+                            element,
+                            "onAfterRunAsync",
+                        );
+                    },
+                },
+                worker: {
+                    ...codeFor(worker),
+                    // 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);
+
             define(TYPE, {
                 config,
                 interpreter,
+                hooks,
                 env: `${TYPE}-script`,
                 version: config?.interpreter,
                 onerror(error, element) {
                     errors.set(element, error);
                 },
-                ...workerHooks,
-                onWorkerReady(_, xworker) {
-                    assign(xworker.sync, sync);
-                    for (const callback of hooks.onWorkerReady)
-                        callback(_, xworker);
-                },
-                onBeforeRun(wrap, element) {
-                    currentElement = element;
-                    bootstrapNodeAndPlugins(
-                        wrap,
-                        element,
-                        before,
-                        "onBeforeRun",
-                    );
-                },
-                onBeforeRunAsync(wrap, element) {
-                    currentElement = element;
-                    bootstrapNodeAndPlugins(
-                        wrap,
-                        element,
-                        before,
-                        "onBeforeRunAsync",
-                    );
-                },
-                onAfterRun(wrap, element) {
-                    bootstrapNodeAndPlugins(wrap, element, after, "onAfterRun");
-                },
-                onAfterRunAsync(wrap, element) {
-                    bootstrapNodeAndPlugins(
-                        wrap,
-                        element,
-                        after,
-                        "onAfterRunAsync",
-                    );
-                },
-                async onInterpreterReady(wrap, element) {
-                    if (shouldRegister) {
-                        shouldRegister = false;
-                        registerModule(wrap);
-                    }
-
-                    // allows plugins to do whatever they want with the element
-                    // before regular stuff happens in here
-                    for (const callback of hooks.onInterpreterReady)
-                        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 {
-                            attributes: { async: isAsync, target },
-                        } = element;
-                        const hasTarget = !!target?.value;
-                        const show = hasTarget
-                            ? queryTarget(element, target.value)
-                            : document.createElement("script-py");
-
-                        if (!hasTarget) {
-                            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);
-                    }
-                    console.debug("[pyscript/main] PyScript Ready");
-                },
             });
 
             customElements.define(
@@ -305,12 +320,13 @@ for (const [TYPE, interpreter] of TYPES) {
  * @returns {Worker & {sync: ProxyHandler<object>}}
  */
 function PyWorker(file, options) {
+    const hooks = hooked.get("py");
     // this propagates pyscript worker hooks without needing a pyscript
     // bootstrap + it passes arguments and enforces `pyodide`
     // as the interpreter to use in the worker, as all hooks assume that
     // and as `pyodide` is the only default interpreter that can deal with
     // all the features we need to deliver pyscript out there.
-    const xworker = XWorker.call(new Hook(null, workerHooks), file, {
+    const xworker = XWorker.call(new Hook(null, hooks), file, {
         type: "pyodide",
         ...options,
     });

package/src/hooks.js

@@ -1,28 +1,91 @@
 import { typedSet } from "type-checked-collections";
+import { dedent } from "polyscript/exports";
+import toJSONCallback from "to-json-callback";
+
+import stdlib from "./stdlib.js";
+
+export const main = (name) => hooks.main[name];
+export const worker = (name) => hooks.worker[name];
+
+const code = (hooks, branch, key, lib) => {
+    hooks[key] = () => {
+        const arr = lib ? [lib] : [];
+        arr.push(...branch(key));
+        return arr.map(dedent).join("\n");
+    };
+};
+
+export const codeFor = (branch) => {
+    const hooks = {};
+    code(hooks, branch, `codeBeforeRun`, stdlib);
+    code(hooks, branch, `codeBeforeRunAsync`, stdlib);
+    code(hooks, branch, `codeAfterRun`);
+    code(hooks, branch, `codeAfterRunAsync`);
+    return hooks;
+};
+
+export const createFunction = (self, name) => {
+    const cbs = [...worker(name)];
+    if (cbs.length) {
+        const cb = toJSONCallback(
+            self[`_${name}`] ||
+                (name.endsWith("Async")
+                    ? async (wrap, xworker, ...cbs) => {
+                          for (const cb of cbs) await cb(wrap, xworker);
+                      }
+                    : (wrap, xworker, ...cbs) => {
+                          for (const cb of cbs) cb(wrap, xworker);
+                      }),
+        );
+        const a = cbs.map(toJSONCallback).join(", ");
+        return Function(`return(w,x)=>(${cb})(w,x,...[${a}])`)();
+    }
+};
 
 const SetFunction = typedSet({ typeof: "function" });
 const SetString = typedSet({ typeof: "string" });
 
-export default {
-    /** @type {Set<function>} */
-    onInterpreterReady: new SetFunction(),
-    /** @type {Set<function>} */
-    onBeforeRun: new SetFunction(),
-    /** @type {Set<function>} */
-    onBeforeRunAsync: new SetFunction(),
-    /** @type {Set<function>} */
-    onAfterRun: new SetFunction(),
-    /** @type {Set<function>} */
-    onAfterRunAsync: new SetFunction(),
-
-    /** @type {Set<function>} */
-    onWorkerReady: new SetFunction(),
-    /** @type {Set<string>} */
-    codeBeforeRunWorker: new SetString(),
-    /** @type {Set<string>} */
-    codeBeforeRunWorkerAsync: new SetString(),
-    /** @type {Set<string>} */
-    codeAfterRunWorker: new SetString(),
-    /** @type {Set<string>} */
-    codeAfterRunWorkerAsync: new SetString(),
+export const hooks = {
+    main: {
+        /** @type {Set<function>} */
+        onWorker: new SetFunction(),
+        /** @type {Set<function>} */
+        onReady: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRunAsync: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRunAsync: new SetFunction(),
+        /** @type {Set<string>} */
+        codeBeforeRun: new SetString(),
+        /** @type {Set<string>} */
+        codeBeforeRunAsync: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRun: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRunAsync: new SetString(),
+    },
+    worker: {
+        /** @type {Set<function>} */
+        onReady: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onBeforeRunAsync: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRun: new SetFunction(),
+        /** @type {Set<function>} */
+        onAfterRunAsync: new SetFunction(),
+        /** @type {Set<string>} */
+        codeBeforeRun: new SetString(),
+        /** @type {Set<string>} */
+        codeBeforeRunAsync: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRun: new SetString(),
+        /** @type {Set<string>} */
+        codeAfterRunAsync: new SetString(),
+    },
 };

package/src/plugins/error.js

@@ -1,9 +1,9 @@
 // PyScript Error Plugin
 import { hooks } from "../core.js";
 
-hooks.onInterpreterReady.add(function override(pyScript) {
+hooks.main.onReady.add(function override(pyScript) {
     // be sure this override happens only once
-    hooks.onInterpreterReady.delete(override);
+    hooks.main.onReady.delete(override);
 
     // trap generic `stderr` to propagate to it regardless
     const { stderr } = pyScript.io;

package/src/plugins-helper.js

@@ -0,0 +1,26 @@
+import { defineProperty } from "polyscript/exports";
+
+// helper for all script[type="py"] out there
+const before = (script) => {
+    defineProperty(document, "currentScript", {
+        configurable: true,
+        get: () => script,
+    });
+};
+
+const after = () => {
+    delete document.currentScript;
+};
+
+// common life-cycle handlers for any node
+export default async (main, wrap, element, hook) => {
+    const isAsync = hook.endsWith("Async");
+    const isBefore = hook.startsWith("onBefore");
+    // make it possible to reach the current target node via Python
+    // or clean up for other scripts executing around this one
+    (isBefore ? before : after)(element);
+    for (const fn of main(hook)) {
+        if (isAsync) await fn(wrap, element);
+        else fn(wrap, element);
+    }
+};

package/types/core.d.ts

@@ -1,4 +1,5 @@
 declare const exportedPyWorker: any;
 declare const exportedHooks: any;
 declare const exportedConfig: any;
-export { exportedPyWorker as PyWorker, exportedHooks as hooks, exportedConfig as config };
+declare const exportedWhenDefined: any;
+export { exportedPyWorker as PyWorker, exportedHooks as hooks, exportedConfig as config, exportedWhenDefined as whenDefined };

package/types/hooks.d.ts

@@ -1,13 +1,38 @@
-declare namespace _default {
-    let onInterpreterReady: Set<Function>;
-    let onBeforeRun: Set<Function>;
-    let onBeforeRunAsync: Set<Function>;
-    let onAfterRun: Set<Function>;
-    let onAfterRunAsync: Set<Function>;
-    let onWorkerReady: Set<Function>;
-    let codeBeforeRunWorker: Set<string>;
-    let codeBeforeRunWorkerAsync: Set<string>;
-    let codeAfterRunWorker: Set<string>;
-    let codeAfterRunWorkerAsync: Set<string>;
+export function main(name: any): any;
+export function worker(name: any): any;
+export function codeFor(branch: any): {};
+export function createFunction(self: any, name: any): any;
+export namespace hooks {
+    namespace main {
+        let onWorker: Set<Function>;
+        let onReady: Set<Function>;
+        let onBeforeRun: Set<Function>;
+        let onBeforeRunAsync: Set<Function>;
+        let onAfterRun: Set<Function>;
+        let onAfterRunAsync: Set<Function>;
+        let codeBeforeRun: Set<string>;
+        let codeBeforeRunAsync: Set<string>;
+        let codeAfterRun: Set<string>;
+        let codeAfterRunAsync: Set<string>;
+    }
+    namespace worker {
+        let onReady_1: Set<Function>;
+        export { onReady_1 as onReady };
+        let onBeforeRun_1: Set<Function>;
+        export { onBeforeRun_1 as onBeforeRun };
+        let onBeforeRunAsync_1: Set<Function>;
+        export { onBeforeRunAsync_1 as onBeforeRunAsync };
+        let onAfterRun_1: Set<Function>;
+        export { onAfterRun_1 as onAfterRun };
+        let onAfterRunAsync_1: Set<Function>;
+        export { onAfterRunAsync_1 as onAfterRunAsync };
+        let codeBeforeRun_1: Set<string>;
+        export { codeBeforeRun_1 as codeBeforeRun };
+        let codeBeforeRunAsync_1: Set<string>;
+        export { codeBeforeRunAsync_1 as codeBeforeRunAsync };
+        let codeAfterRun_1: Set<string>;
+        export { codeAfterRun_1 as codeAfterRun };
+        let codeAfterRunAsync_1: Set<string>;
+        export { codeAfterRunAsync_1 as codeAfterRunAsync };
+    }
 }
-export default _default;

package/types/plugins-helper.d.ts

@@ -0,0 +1,2 @@
+declare function _default(main: any, wrap: any, element: any, hook: any): Promise<void>;
+export default _default;

package/dist/error-0_IesYFM.js

@@ -1,2 +0,0 @@
-import{hooks as e}from"./core.js";function r(e){const r=document.createElement("div");r.className="py-error",r.textContent=e,r.style.cssText="\n    border: 1px solid red;\n    background: #ffdddd;\n    color: black;\n    font-family: courier, monospace;\n    white-space: pre;\n    overflow-x: auto;\n    padding: 8px;\n    margin-top: 8px;\n  ",document.body.append(r)}e.onInterpreterReady.add((function o(n){e.onInterpreterReady.delete(o);const{stderr:t}=n.io;n.io.stderr=(e,...o)=>(r(e.message||e),t(e,...o)),addEventListener("error",(({message:e})=>{e.startsWith("Uncaught PythonError")&&r(e)}))}));export{r as notify};
-//# sourceMappingURL=error-0_IesYFM.js.map

package/dist/error-0_IesYFM.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-0_IesYFM.js","sources":["../src/plugins/error.js"],"sourcesContent":["// PyScript Error Plugin\nimport { hooks } from \"../core.js\";\n\nhooks.onInterpreterReady.add(function override(pyScript) {\n    // be sure this override happens only once\n    hooks.onInterpreterReady.delete(override);\n\n    // trap generic `stderr` to propagate to it regardless\n    const { stderr } = pyScript.io;\n\n    // override it with our own logic\n    pyScript.io.stderr = (error, ...rest) => {\n        notify(error.message || error);\n        // let other plugins or stderr hook, if any, do the rest\n        return stderr(error, ...rest);\n    };\n\n    // be sure uncaught Python errors are also visible\n    addEventListener(\"error\", ({ message }) => {\n        if (message.startsWith(\"Uncaught PythonError\")) notify(message);\n    });\n});\n\n// Error hook utilities\n\n// Custom function to show notifications\n\n/**\n * Add a banner to the top of the page, notifying the user of an error\n * @param {string} message\n */\nexport function notify(message) {\n    const div = document.createElement(\"div\");\n    div.className = \"py-error\";\n    div.textContent = message;\n    div.style.cssText = `\n    border: 1px solid red;\n    background: #ffdddd;\n    color: black;\n    font-family: courier, monospace;\n    white-space: pre;\n    overflow-x: auto;\n    padding: 8px;\n    margin-top: 8px;\n  `;\n    document.body.append(div);\n}\n"],"names":["notify","message","div","document","createElement","className","textContent","style","cssText","body","append","hooks","onInterpreterReady","add","override","pyScript","delete","stderr","io","error","rest","addEventListener","startsWith"],"mappings":"kCA+BO,SAASA,EAAOC,GACnB,MAAMC,EAAMC,SAASC,cAAc,OACnCF,EAAIG,UAAY,WAChBH,EAAII,YAAcL,EAClBC,EAAIK,MAAMC,QAAU,6MAUpBL,SAASM,KAAKC,OAAOR,EACzB,CA3CAS,EAAMC,mBAAmBC,KAAI,SAASC,EAASC,GAE3CJ,EAAMC,mBAAmBI,OAAOF,GAGhC,MAAMG,OAAEA,GAAWF,EAASG,GAG5BH,EAASG,GAAGD,OAAS,CAACE,KAAUC,KAC5BpB,EAAOmB,EAAMlB,SAAWkB,GAEjBF,EAAOE,KAAUC,IAI5BC,iBAAiB,SAAS,EAAGpB,cACrBA,EAAQqB,WAAW,yBAAyBtB,EAAOC,EAAQ,GAEvE"}