@pyscript/core 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pyscript/core",
-    "version": "0.2.3",
+    "version": "0.2.4",
     "type": "module",
     "description": "PyScript",
     "module": "./index.js",
@@ -20,7 +20,7 @@
     },
     "scripts": {
         "server": "npx static-handler --cors --coep --coop --corp .",
-        "build": "node rollup/stdlib.cjs && node rollup/plugins.cjs && rm -rf dist && rollup --config rollup/core.config.js && npm run ts",
+        "build": "node rollup/stdlib.cjs && node rollup/plugins.cjs && rm -rf dist && rollup --config rollup/core.config.js && eslint src/ && npm run ts",
         "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 ."
     },
@@ -33,11 +33,12 @@
     "dependencies": {
         "@ungap/with-resolvers": "^0.1.0",
         "basic-devtools": "^0.1.6",
-        "polyscript": "^0.4.2"
+        "polyscript": "^0.4.6"
     },
     "devDependencies": {
         "@rollup/plugin-node-resolve": "^15.2.1",
         "@rollup/plugin-terser": "^0.4.3",
+        "eslint": "^8.50.0",
         "rollup": "^3.29.3",
         "rollup-plugin-postcss": "^4.0.2",
         "rollup-plugin-string": "^3.0.0",

package/src/all-done.js

@@ -0,0 +1,62 @@
+import TYPES from "./types.js";
+import hooks from "./hooks.js";
+
+const DONE = "py:all-done";
+
+const {
+    onAfterRun,
+    onAfterRunAsync,
+    codeAfterRunWorker,
+    codeAfterRunWorkerAsync,
+} = hooks;
+
+const waitForIt = [];
+const codes = [];
+
+const codeFor = (element) => {
+    const isAsync = element.hasAttribute("async");
+    const { promise, resolve } = Promise.withResolvers();
+    const type = `${DONE}:${waitForIt.push(promise)}`;
+
+    // resolve each promise once notified
+    addEventListener(type, resolve, { once: true });
+
+    if (element.hasAttribute("worker")) {
+        const code = `
+            from pyscript import window as _w
+            _w.dispatchEvent(_w.Event.new("${type}"))
+        `;
+        if (isAsync) codeAfterRunWorkerAsync.add(code);
+        else codeAfterRunWorker.add(code);
+        return code;
+    }
+
+    // dispatch only once the ready element is the same
+    const code = (_, el) => {
+        if (el === element) dispatchEvent(new Event(type));
+    };
+
+    if (isAsync) onAfterRunAsync.add(code);
+    else onAfterRun.add(code);
+    return code;
+};
+
+const selector = [];
+for (const [TYPE] of TYPES)
+    selector.push(`script[type="${TYPE}"]`, `${TYPE}-script`);
+
+// loop over all known scripts and elements
+for (const element of document.querySelectorAll(selector.join(",")))
+    codes.push(codeFor(element));
+
+// wait for all the things then cleanup
+Promise.all(waitForIt).then(() => {
+    // cleanup unnecessary hooks
+    for (const code of codes) {
+        onAfterRun.delete(code);
+        onAfterRunAsync.delete(code);
+        codeAfterRunWorker.delete(code);
+        codeAfterRunWorkerAsync.delete(code);
+    }
+    dispatchEvent(new Event(DONE));
+});

package/src/core.js

@@ -1,16 +1,21 @@
 /*! (c) PyScript Development Team */
 
 import "@ungap/with-resolvers";
-import { INVALID_CONTENT, define, XWorker } from "polyscript";
 
-// TODO: this is not strictly polyscript related but handy ... not sure
-//       we should factor this utility out a part but this works anyway.
+// These imports can hook more than usual and help debugging possible polyscript issues
+import {
+    INVALID_CONTENT,
+    define,
+    XWorker,
+} from "../node_modules/polyscript/esm/index.js";
 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 "./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 { ErrorCode } from "./exceptions.js";
@@ -66,28 +71,6 @@ const registerModule = ({ XWorker: $XWorker, interpreter, io }) => {
     interpreter.runPython(stdlib, { globals: interpreter.runPython("{}") });
 };
 
-export const hooks = {
-    /** @type {Set<function>} */
-    onBeforeRun: new Set(),
-    /** @type {Set<function>} */
-    onBeforeRunAsync: new Set(),
-    /** @type {Set<function>} */
-    onAfterRun: new Set(),
-    /** @type {Set<function>} */
-    onAfterRunAsync: new Set(),
-    /** @type {Set<function>} */
-    onInterpreterReady: new Set(),
-
-    /** @type {Set<string>} */
-    codeBeforeRunWorker: new Set(),
-    /** @type {Set<string>} */
-    codeBeforeRunWorkerAsync: new Set(),
-    /** @type {Set<string>} */
-    codeAfterRunWorker: new Set(),
-    /** @type {Set<string>} */
-    codeAfterRunWorkerAsync: new Set(),
-};
-
 const workerHooks = {
     codeBeforeRunWorker: () =>
         [stdlib, ...hooks.codeBeforeRunWorker].map(dedent).join("\n"),
@@ -100,7 +83,7 @@ const workerHooks = {
 };
 
 const exportedConfig = {};
-export { exportedConfig as config };
+export { exportedConfig as config, hooks };
 
 for (const [TYPE, interpreter] of TYPES) {
     const { config, plugins, error } = configs.get(TYPE);
@@ -206,7 +189,7 @@ for (const [TYPE, interpreter] of TYPES) {
                     } = element;
                     const hasTarget = !!target?.value;
                     const show = hasTarget
-                        ? queryTarget(target.value)
+                        ? queryTarget(element, target.value)
                         : document.createElement("script-py");
 
                     if (!hasTarget) {

package/src/hooks.js

@@ -0,0 +1,21 @@
+export default {
+    /** @type {Set<function>} */
+    onBeforeRun: new Set(),
+    /** @type {Set<function>} */
+    onBeforeRunAsync: new Set(),
+    /** @type {Set<function>} */
+    onAfterRun: new Set(),
+    /** @type {Set<function>} */
+    onAfterRunAsync: new Set(),
+    /** @type {Set<function>} */
+    onInterpreterReady: new Set(),
+
+    /** @type {Set<string>} */
+    codeBeforeRunWorker: new Set(),
+    /** @type {Set<string>} */
+    codeBeforeRunWorkerAsync: new Set(),
+    /** @type {Set<string>} */
+    codeAfterRunWorker: new Set(),
+    /** @type {Set<string>} */
+    codeAfterRunWorkerAsync: new Set(),
+};

package/types/all-done.d.ts

@@ -0,0 +1 @@
+export {};

package/types/core.d.ts

@@ -10,17 +10,7 @@ export function PyWorker(file: string, options?: {
 }): Worker & {
     sync: ProxyHandler<object>;
 };
-export namespace hooks {
-    let onBeforeRun: Set<Function>;
-    let onBeforeRunAsync: Set<Function>;
-    let onAfterRun: Set<Function>;
-    let onAfterRunAsync: Set<Function>;
-    let onInterpreterReady: Set<Function>;
-    let codeBeforeRunWorker: Set<string>;
-    let codeBeforeRunWorkerAsync: Set<string>;
-    let codeAfterRunWorker: Set<string>;
-    let codeAfterRunWorkerAsync: Set<string>;
-}
-export { exportedConfig as config };
 import sync from "./sync.js";
 declare const exportedConfig: {};
+import hooks from "./hooks.js";
+export { exportedConfig as config, hooks };

package/types/hooks.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    let onBeforeRun: Set<Function>;
+    let onBeforeRunAsync: Set<Function>;
+    let onAfterRun: Set<Function>;
+    let onAfterRunAsync: Set<Function>;
+    let onInterpreterReady: Set<Function>;
+    let codeBeforeRunWorker: Set<string>;
+    let codeBeforeRunWorkerAsync: Set<string>;
+    let codeAfterRunWorker: Set<string>;
+    let codeAfterRunWorkerAsync: Set<string>;
+}
+export default _default;