rapydscript-ns 0.8.2 → 0.8.4

package/test/unit/web-repl.js

@@ -119,6 +119,70 @@ function run_js(js) {
     });
 }
 
+// Minimal React stub — mirrors the one in web-repl/env.js so that compiled
+// code that imports from the react library can run in a plain Node vm context.
+var REACT_STUB = (function () {
+    var Fragment = Symbol("React.Fragment");
+    function createElement(type, props) {
+        var children = Array.prototype.slice.call(arguments, 2);
+        return { type: type, props: Object.assign({ children: children.length === 1 ? children[0] : children }, props) };
+    }
+    function useState(initial) {
+        var s = typeof initial === "function" ? initial() : initial;
+        return [s, function (v) { s = typeof v === "function" ? v(s) : v; }];
+    }
+    function useEffect(fn)    { fn(); }
+    function useLayoutEffect(fn) { fn(); }
+    function useMemo(fn)      { return fn(); }
+    function useCallback(fn)  { return fn; }
+    function useRef(initial)  { return { current: initial }; }
+    function useContext(ctx)  { return ctx && ctx._currentValue !== undefined ? ctx._currentValue : undefined; }
+    function useReducer(reducer, initial) { return [initial, function (a) {}]; }
+    function useImperativeHandle(ref, create) { if (ref) ref.current = create(); }
+    function useDebugValue() {}
+    function useId() { return ":r" + (Math.random() * 1e9 | 0) + ":"; }
+    function useTransition() { return [false, function (fn) { fn(); }]; }
+    function useDeferredValue(v) { return v; }
+    function useSyncExternalStore(sub, get) { return get(); }
+    function useInsertionEffect(fn) { fn(); }
+    function createContext(def) { return { _currentValue: def }; }
+    function createRef() { return { current: null }; }
+    function forwardRef(render) { return function (props) { return render(props, null); }; }
+    function memo(C)  { return C; }
+    function lazy(f)  { return f; }
+    function cloneElement(el, props) { return Object.assign({}, el, { props: Object.assign({}, el.props, props) }); }
+    function isValidElement(o) { return o !== null && typeof o === "object" && o.type !== undefined; }
+    function Component() {}
+    Component.prototype.setState = function (u) { this.state = Object.assign({}, this.state, typeof u === "function" ? u(this.state) : u); };
+    function PureComponent() {}
+    PureComponent.prototype = Object.create(Component.prototype);
+    PureComponent.prototype.constructor = PureComponent;
+    return {
+        Fragment: Fragment, createElement: createElement,
+        useState: useState, useEffect: useEffect, useLayoutEffect: useLayoutEffect,
+        useMemo: useMemo, useCallback: useCallback, useRef: useRef,
+        useContext: useContext, useReducer: useReducer,
+        useImperativeHandle: useImperativeHandle, useDebugValue: useDebugValue,
+        useId: useId, useTransition: useTransition, useDeferredValue: useDeferredValue,
+        useSyncExternalStore: useSyncExternalStore, useInsertionEffect: useInsertionEffect,
+        createContext: createContext, createRef: createRef, forwardRef: forwardRef,
+        memo: memo, lazy: lazy, cloneElement: cloneElement, isValidElement: isValidElement,
+        Component: Component, PureComponent: PureComponent,
+        StrictMode: {}, Suspense: {}, Profiler: {},
+    };
+})();
+
+// Run compiled JS in a vm context that also has a React stub available.
+function run_js_with_react(js) {
+    return vm.runInNewContext(js, {
+        __name__          : "<test>",
+        console           : console,
+        assrt             : assert,
+        ρσ_last_exception : undefined,
+        React             : REACT_STUB,
+    });
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -445,6 +509,379 @@ var TESTS = [
         },
     },
 
+    {
+        name: "nested_class_web_repl",
+        description: "Nested class definitions compile and run correctly via the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class Outer:",
+                "    class Inner:",
+                "        def __init__(self, val):",
+                "            self.val = val",
+                "    def __init__(self, v):",
+                "        self.inner = Outer.Inner(v)",
+                "o = Outer(99)",
+                "assrt.equal(o.inner.val, 99)",
+                "assrt.ok(isinstance(o.inner, Outer.Inner))",
+                "assrt.ok(o.Inner is Outer.Inner)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── slice() builtin ───────────────────────────────────────────────────
+
+    {
+        name: "bundle_slice_constructor",
+        description: "slice() constructor stores start/stop/step attributes correctly",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s1 = slice(5)",
+                "assrt.equal(s1.start, None)",
+                "assrt.equal(s1.stop, 5)",
+                "assrt.equal(s1.step, None)",
+                "s2 = slice(2, 8)",
+                "assrt.equal(s2.start, 2)",
+                "assrt.equal(s2.stop, 8)",
+                "assrt.equal(s2.step, None)",
+                "s3 = slice(1, 9, 2)",
+                "assrt.equal(s3.start, 1)",
+                "assrt.equal(s3.stop, 9)",
+                "assrt.equal(s3.step, 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_subscript",
+        description: "slice object used as list subscript returns the correct sub-list",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import overload_getitem",
+                "lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]",
+                "s = slice(2, 5)",
+                "assrt.deepEqual(lst[s], [2, 3, 4])",
+                "assrt.deepEqual(lst[slice(0, 6, 2)], [0, 2, 4])",
+                "assrt.deepEqual(lst[slice(5, 1, -1)], [5, 4, 3, 2])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_indices",
+        description: "slice.indices() returns normalised (start, stop, step) tuple",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s = slice(2, 8)",
+                "idx = s.indices(10)",
+                "assrt.equal(idx[0], 2)",
+                "assrt.equal(idx[1], 8)",
+                "assrt.equal(idx[2], 1)",
+                "# negative indices normalised",
+                "s2 = slice(-3, -1)",
+                "idx2 = s2.indices(10)",
+                "assrt.equal(idx2[0], 7)",
+                "assrt.equal(idx2[1], 9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_repr",
+        description: "str(slice(...)) produces the Python-style repr",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "assrt.equal(str(slice(1, 5, None)), 'slice(1, 5, None)')",
+                "assrt.equal(str(slice(None, 5, 2)), 'slice(None, 5, 2)')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_isinstance",
+        description: "isinstance(slice(...), slice) returns True in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s = slice(1, 5)",
+                "assrt.ok(isinstance(s, slice))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_tuple_annotation_variable",
+        description: "variable type annotation with tuple does not become a function call",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "# globals: assrt",
+                "range_limits: tuple = (0, 100)",
+                "assrt.equal(range_limits[0], 0)",
+                "assrt.equal(range_limits[1], 100)",
+            ].join("\n"));
+            // Ensure it compiled to an assignment, not a call
+            if (/range_limits\s*\(/.test(js)) throw new Error("range_limits was compiled as a function call:\n" + js);
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_tuple_annotation_function_arg",
+        description: "function argument type annotation with tuple and int works at runtime",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "# globals: assrt",
+                "def clamp(val: int, bounds: tuple) -> int:",
+                "    lo, hi = bounds",
+                "    return max(lo, min(hi, val))",
+                "range_limits: tuple = (0, 100)",
+                "assrt.equal(clamp(150, range_limits), 100)",
+                "assrt.equal(clamp(-5,  range_limits), 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_list_concatenation",
+        description: "list + list returns a concatenated list in the bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "a = [1, 2]",
+                "b = [3, 4]",
+                "c = a + b",
+                "assrt.deepEqual(c, [1, 2, 3, 4])",
+                "assrt.deepEqual(a, [1, 2])",
+                "assrt.deepEqual(b, [3, 4])",
+                "# iadd extends in-place",
+                "a += [5]",
+                "assrt.deepEqual(a, [1, 2, 5])",
+                "# numbers still work",
+                "assrt.equal(1 + 2, 3)",
+                "# strings still work",
+                "assrt.equal('foo' + 'bar', 'foobar')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── React stub tests ─────────────────────────────────────────────────────
+    // These tests require a React mock in the vm context because the compiled
+    // react.pyj module initialises with `React.*` references at load time.
+
+    {
+        name: "bundle_react_stub_memo",
+        description: "web-repl React stub: memo() returns its argument (identity wrapper)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import memo",
+                "def MyComp(props): return props.x",
+                "Memoised = memo(MyComp)",
+                "assrt.equal(Memoised, MyComp)",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_usestate",
+        description: "web-repl React stub: useState returns [initialValue, setter]",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useState",
+                "state, setState = useState(42)",
+                "assrt.equal(state, 42)",
+                "assrt.equal(jstype(setState), 'function')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_useeffect",
+        description: "web-repl React stub: useEffect calls its callback immediately",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useEffect",
+                "ran = [False]",
+                "def effect(): ran[0] = True",
+                "useEffect(effect, [])",
+                "assrt.ok(ran[0])",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_usememo",
+        description: "web-repl React stub: useMemo returns the computed value",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useMemo",
+                "result = useMemo(def(): return 6 * 7;, [])",
+                "assrt.equal(result, 42)",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_useref",
+        description: "web-repl React stub: useRef returns {current: initialValue}",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useRef",
+                "ref = useRef(None)",
+                "assrt.equal(ref.current, None)",
+                "ref.current = 'hello'",
+                "assrt.equal(ref.current, 'hello')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_usereducer",
+        description: "web-repl React stub: useReducer returns [initialState, dispatch]",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useReducer",
+                "def reducer(state, action):",
+                "    if action == 'inc': return state + 1",
+                "    return state",
+                "state, dispatch = useReducer(reducer, 0)",
+                "assrt.equal(state, 0)",
+                "assrt.equal(jstype(dispatch), 'function')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_createcontext",
+        description: "web-repl React stub: createContext returns a context with default value",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import createContext, useContext",
+                "ThemeCtx = createContext('dark')",
+                "theme = useContext(ThemeCtx)",
+                "assrt.equal(theme, 'dark')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_forwardref",
+        description: "web-repl React stub: forwardRef wraps the render function",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import forwardRef",
+                "def render(props, ref): return props.x",
+                "FancyInput = forwardRef(render)",
+                "assrt.equal(jstype(FancyInput), 'function')",
+                "assrt.equal(FancyInput({'x': 99}), 99)",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_jsx_and_memo",
+        description: "web-repl React stub: JSX component wrapped with memo compiles and runs",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import jsx",
+                "from react import useState, memo",
+                "def Counter(props):",
+                "    count, setCount = useState(props.initial or 0)",
+                "    return <span>{count}</span>",
+                "MemoCounter = memo(Counter)",
+                "assrt.equal(jstype(MemoCounter), 'function')",
+                "el = MemoCounter({'initial': 7})",
+                "assrt.equal(el.type, 'span')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    // ── __import__() ─────────────────────────────────────────────────────
+
+    {
+        name: "bundle___import__-basic",
+        description: "__import__(name) returns a stdlib module reference in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import Counter",
+                "m = __import__('collections')",
+                // m.Counter should be the same object as the statically-imported Counter
+                "assrt.ok(m.Counter is Counter)",
+                "c = m.Counter('aabb')",
+                "top = c.most_common(1)",
+                "assrt.equal(top[0][0], 'a')",
+                "assrt.equal(top[0][1], 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle___import__-fromlist",
+        description: "__import__ with fromlist returns the exact named module",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import deque",
+                "m = __import__('collections', None, None, ['deque'])",
+                "d = m.deque([1, 2, 3])",
+                "assrt.equal(len(d), 3)",
+                "assrt.equal(d.popleft(), 1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle___import__-error",
+        description: "__import__ raises ModuleNotFoundError for unknown module in web-repl",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import Counter",
+                "caught = False",
+                "try:",
+                "    __import__('no_such_module')",
+                "except ModuleNotFoundError as e:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
 ];
 
 // ---------------------------------------------------------------------------

package/tools/build-language-service.js

@@ -14,7 +14,7 @@ var path = require("path");
 
 var SRC_DIR     = path.join(__dirname, "..", "src", "monaco-language-service");
 var COMPILER_JS = path.join(__dirname, "..", "web-repl", "rapydscript.js");
-var DEFAULT_OUT = path.join(__dirname, "..", "web-repl", "language-service.js");
+var DEFAULT_OUT = path.join(__dirname, "..", "language-service", "index.js");
 
 // Parse --out flag
 var out_path = DEFAULT_OUT;
@@ -124,7 +124,7 @@ var chunks = [
     "// language-service.js — RapydScript Monaco Language Service",
     "// Auto-generated by tools/build-language-service.js — do not edit directly.",
     "// Source: src/monaco-language-service/  +  web-repl/rapydscript.js (embedded)",
-    "// Usage:  import { registerRapydScript } from './language-service.js';",
+    "// Usage:  import { registerRapydScript } from 'rapydscript-ns/language-service';",
     "//         No external compiler bundle needed — the compiler is bundled inside.",
     "",
     compiler_chunk,