rapydscript-ns 0.8.2 → 0.8.4

package/src/lib/react.pyj

@@ -0,0 +1,74 @@
+# vim:fileencoding=utf-8
+# License: BSD
+# RapydScript bindings for React.
+#
+# Supported: all standard hooks (useState, useEffect, useContext, useReducer,
+# useCallback, useMemo, useRef, useImperativeHandle, useLayoutEffect,
+# useDebugValue, useId, useTransition, useDeferredValue), core classes
+# (Component, PureComponent), special elements (Fragment, StrictMode,
+# Suspense, Profiler), and utilities (createElement, cloneElement,
+# createContext, createRef, forwardRef, isValidElement, memo, lazy).
+#
+# Requires React to be available as a global variable.  Load it via a CDN
+# <script> tag, a bundler global shim, or any other mechanism before your
+# compiled script runs.
+#
+# Usage:
+#   from __python__ import jsx
+#   from react import useState, useEffect, useRef
+#
+#   def Counter():
+#       count, setCount = useState(0)
+#       def handleClick():
+#           setCount(count + 1)
+#       return <button onClick={handleClick}>{count}</button>
+#
+# For class components extend React.Component directly (no import needed):
+#
+#   class MyComponent(React.Component):
+#       def render(self):
+#           return <div>{self.props.title}</div>
+
+# ── Hooks (React 16.8+) ───────────────────────────────────────────────────────
+
+useState             = React.useState
+useEffect            = React.useEffect
+useContext           = React.useContext
+useReducer           = React.useReducer
+useCallback          = React.useCallback
+useMemo              = React.useMemo
+useRef               = React.useRef
+useImperativeHandle  = React.useImperativeHandle
+useLayoutEffect      = React.useLayoutEffect
+useDebugValue        = React.useDebugValue
+
+# ── Hooks (React 18+) ────────────────────────────────────────────────────────
+
+useId                = React.useId
+useTransition        = React.useTransition
+useDeferredValue     = React.useDeferredValue
+useSyncExternalStore = React.useSyncExternalStore
+useInsertionEffect   = React.useInsertionEffect
+
+# ── Core classes ─────────────────────────────────────────────────────────────
+
+Component            = React.Component
+PureComponent        = React.PureComponent
+
+# ── Special elements ─────────────────────────────────────────────────────────
+
+Fragment             = React.Fragment
+StrictMode           = React.StrictMode
+Suspense             = React.Suspense
+Profiler             = React.Profiler
+
+# ── Utilities ────────────────────────────────────────────────────────────────
+
+createElement        = React.createElement
+cloneElement         = React.cloneElement
+createContext        = React.createContext
+createRef            = React.createRef
+forwardRef           = React.forwardRef
+isValidElement       = React.isValidElement
+memo                 = React.memo
+lazy                 = React.lazy

package/src/lib/traceback.pyj

@@ -1,63 +1,63 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: ρσ_str, ρσ_last_exception
-
-
-def _get_internal_traceback(err):
-    if isinstance(err, Exception) and err.stack:
-        lines = ρσ_str.splitlines(err.stack)
-        final_lines = v'[]'
-        found_sentinel = False
-        for i, line in enumerate(lines):
-            sline = ρσ_str.strip(line)
-            if i is 0:
-                final_lines.push(line)
-                continue
-            if found_sentinel:
-                final_lines.push(line)
-                continue
-            # These two conditions work on desktop Chrome and Firefox to identify the correct
-            # line in the traceback.
-            if sline.startsWith('at new ' + err.name) or sline.startsWith(err.name + '@'):
-                found_sentinel = True
-        return final_lines.join('\n')
-    return err and err.stack
-
-def format_exception(exc, limit):
-    if jstype(exc) is 'undefined':
-        exc = ρσ_last_exception
-    if not isinstance(exc, Error):
-        if exc and exc.toString:
-            return [exc.toString()]
-        return []
-    tb = _get_internal_traceback(exc)
-    if tb:
-        lines = ρσ_str.splitlines(tb)
-        e = lines[0]
-        lines = lines[1:]
-        if limit:
-            lines = lines[:limit+1] if limit > 0 else lines[limit:]
-        lines.reverse()
-        lines.push(e)
-        lines.insert(0, 'Traceback (most recent call last):')
-        return [l+'\n' for l in lines]
-    return [exc.toString()]
-
-def format_exc(limit):
-    return format_exception(ρσ_last_exception, limit).join('')
-
-def print_exc(limit):
-    print(format_exc(limit))
-
-def format_stack(limit):
-    stack = Error().stack
-    if not stack:
-        return []
-    lines = str.splitlines(stack)[2:]
-    lines.reverse()
-    if limit:
-        lines = lines[:limit+1] if limit > 0 else lines[limit:]
-    return [l + '\n' for l in lines]
-
-def print_stack(limit):
-    print(format_stack(limit).join(''))
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: ρσ_str, ρσ_last_exception
+
+
+def _get_internal_traceback(err):
+    if isinstance(err, Exception) and err.stack:
+        lines = ρσ_str.splitlines(err.stack)
+        final_lines = v'[]'
+        found_sentinel = False
+        for i, line in enumerate(lines):
+            sline = ρσ_str.strip(line)
+            if i is 0:
+                final_lines.push(line)
+                continue
+            if found_sentinel:
+                final_lines.push(line)
+                continue
+            # These two conditions work on desktop Chrome and Firefox to identify the correct
+            # line in the traceback.
+            if sline.startsWith('at new ' + err.name) or sline.startsWith(err.name + '@'):
+                found_sentinel = True
+        return final_lines.join('\n')
+    return err and err.stack
+
+def format_exception(exc, limit):
+    if jstype(exc) is 'undefined':
+        exc = ρσ_last_exception
+    if not isinstance(exc, Error):
+        if exc and exc.toString:
+            return [exc.toString()]
+        return []
+    tb = _get_internal_traceback(exc)
+    if tb:
+        lines = ρσ_str.splitlines(tb)
+        e = lines[0]
+        lines = lines[1:]
+        if limit:
+            lines = lines[:limit+1] if limit > 0 else lines[limit:]
+        lines.reverse()
+        lines.push(e)
+        lines.insert(0, 'Traceback (most recent call last):')
+        return [l+'\n' for l in lines]
+    return [exc.toString()]
+
+def format_exc(limit):
+    return format_exception(ρσ_last_exception, limit).join('')
+
+def print_exc(limit):
+    print(format_exc(limit))
+
+def format_stack(limit):
+    stack = Error().stack
+    if not stack:
+        return []
+    lines = str.splitlines(stack)[2:]
+    lines.reverse()
+    if limit:
+        lines = lines[:limit+1] if limit > 0 else lines[limit:]
+    return [l + '\n' for l in lines]
+
+def print_stack(limit):
+    print(format_stack(limit).join(''))

package/src/lib/uuid.pyj

@@ -1,77 +1,77 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: crypto
-from __python__ import hash_literals
-
-from encodings import hexlify, urlsafe_b64decode, urlsafe_b64encode
-
-RFC_4122 = 1
-
-if jstype(crypto) is 'object' and crypto.getRandomValues:
-    random_bytes = def (num):
-        ans = Uint8Array(num or 16)
-        crypto.getRandomValues(ans)
-        return ans
-else:
-    random_bytes = def (num):
-        ans = Uint8Array(num or 16)
-        for i in range(ans.length):
-            ans[i] = Math.floor(Math.random() * 256)
-        return ans
-
-
-def uuid4_bytes():
-    data = random_bytes()
-    data[6] = 0b01000000 | (data[6] & 0b1111)
-    data[8] = (((data[8] >> 4) & 0b11 | 0b1000) << 4) | (data[8] & 0b1111)
-    return data
-
-
-def as_str():
-    h = this.hex
-    return h[:8] + '-' + h[8:12] + '-' + h[12:16] + '-' + h[16:20] + '-' + h[20:]
-
-
-def uuid4():
-    b = uuid4_bytes()
-    return {
-        'hex': hexlify(b),
-        'bytes': b,
-        'variant': RFC_4122,
-        'version': 4,
-        '__str__': as_str,
-        'toString': as_str,
-    }
-
-
-def num_to_string(numbers, alphabet, pad_to_length):
-    ans = v'[]'
-    alphabet_len = alphabet.length
-    numbers = Array.prototype.slice.call(numbers)
-    for v'var i = 0; i < numbers.length - 1; i++':
-        x = divmod(numbers[i], alphabet_len)
-        numbers[i] = x[0]
-        numbers[i+1] += x[1]
-    for v'var i = 0; i < numbers.length; i++':
-        number = numbers[i]
-        while number:
-            x = divmod(number, alphabet_len)
-            number = x[0]
-            ans.push(alphabet[x[1]])
-    if pad_to_length and pad_to_length > ans.length:
-        ans.push(alphabet[0].repeat(pad_to_length - ans.length))
-    return ans.join('')
-
-
-def short_uuid():
-    # A totally random uuid encoded using only URL and filename safe characters
-    return urlsafe_b64encode(random_bytes(), '')
-
-
-def short_uuid4():
-    # A uuid4 encoded using only URL and filename safe characters
-    return urlsafe_b64encode(uuid4_bytes(), '')
-
-
-def decode_short_uuid(val):
-    return urlsafe_b64decode(val + '==')
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: crypto
+from __python__ import hash_literals
+
+from encodings import hexlify, urlsafe_b64decode, urlsafe_b64encode
+
+RFC_4122 = 1
+
+if jstype(crypto) is 'object' and crypto.getRandomValues:
+    random_bytes = def (num):
+        ans = Uint8Array(num or 16)
+        crypto.getRandomValues(ans)
+        return ans
+else:
+    random_bytes = def (num):
+        ans = Uint8Array(num or 16)
+        for i in range(ans.length):
+            ans[i] = Math.floor(Math.random() * 256)
+        return ans
+
+
+def uuid4_bytes():
+    data = random_bytes()
+    data[6] = 0b01000000 | (data[6] & 0b1111)
+    data[8] = (((data[8] >> 4) & 0b11 | 0b1000) << 4) | (data[8] & 0b1111)
+    return data
+
+
+def as_str():
+    h = this.hex
+    return h[:8] + '-' + h[8:12] + '-' + h[12:16] + '-' + h[16:20] + '-' + h[20:]
+
+
+def uuid4():
+    b = uuid4_bytes()
+    return {
+        'hex': hexlify(b),
+        'bytes': b,
+        'variant': RFC_4122,
+        'version': 4,
+        '__str__': as_str,
+        'toString': as_str,
+    }
+
+
+def num_to_string(numbers, alphabet, pad_to_length):
+    ans = v'[]'
+    alphabet_len = alphabet.length
+    numbers = Array.prototype.slice.call(numbers)
+    for v'var i = 0; i < numbers.length - 1; i++':
+        x = divmod(numbers[i], alphabet_len)
+        numbers[i] = x[0]
+        numbers[i+1] += x[1]
+    for v'var i = 0; i < numbers.length; i++':
+        number = numbers[i]
+        while number:
+            x = divmod(number, alphabet_len)
+            number = x[0]
+            ans.push(alphabet[x[1]])
+    if pad_to_length and pad_to_length > ans.length:
+        ans.push(alphabet[0].repeat(pad_to_length - ans.length))
+    return ans.join('')
+
+
+def short_uuid():
+    # A totally random uuid encoded using only URL and filename safe characters
+    return urlsafe_b64encode(random_bytes(), '')
+
+
+def short_uuid4():
+    # A uuid4 encoded using only URL and filename safe characters
+    return urlsafe_b64encode(uuid4_bytes(), '')
+
+
+def decode_short_uuid(val):
+    return urlsafe_b64decode(val + '==')

package/src/monaco-language-service/analyzer.js

@@ -46,6 +46,95 @@ function dot_path_from_node(node, RS) {
     return null;
 }
 
+/**
+ * Infer the type of a single return-value expression.
+ * Returns a type string ('list', 'dict', 'str', 'number', 'bool', or a class name),
+ * or null if the type cannot be determined from this expression alone.
+ *
+ * @param {object}     node   - The AST expression node (return value)
+ * @param {ScopeFrame} scope  - The function's own scope frame (fully populated)
+ * @param {object}     RS     - RapydScript compiler object
+ * @returns {string|null}
+ */
+function infer_expr_type(node, scope, RS) {
+    if (node instanceof RS.AST_Array)  return 'list';
+    if (node instanceof RS.AST_Object) return 'dict';
+    if (node instanceof RS.AST_String) return 'str';
+    if (node instanceof RS.AST_Number) return 'number';
+    if ((RS.AST_True  && node instanceof RS.AST_True) ||
+        (RS.AST_False && node instanceof RS.AST_False)) return 'bool';
+    if (RS.AST_Null && node instanceof RS.AST_Null) return null;  // None → not counted
+
+    if (node instanceof RS.AST_SymbolRef) {
+        const sym = scope ? scope.getSymbol(node.name) : null;
+        return (sym && sym.inferred_class) ? sym.inferred_class : null;
+    }
+
+    if (node instanceof RS.AST_BaseCall && node.expression instanceof RS.AST_SymbolRef) {
+        const name = node.expression.name;
+        // PascalCase → assume class constructor, use name as type
+        if (/^[A-Z]/.test(name)) return name;
+        // Known local function with an already-resolved return_type
+        const sym = scope ? scope.getSymbol(name) : null;
+        if (sym && sym.return_type) return sym.return_type;
+    }
+
+    return null;
+}
+
+/**
+ * Walk a function node's body, collect all return-expression types, and return
+ * the single inferred type if every non-None return agrees on one type.
+ * Skips nested function bodies (their returns don't belong to this function).
+ * Returns null if returns disagree, are unrecognised, or the body has no typed returns.
+ *
+ * @param {object}     func_node  - AST_Lambda node
+ * @param {ScopeFrame} func_scope - The function's own scope frame (already populated)
+ * @param {object}     RS         - RapydScript compiler object
+ * @returns {string|null}
+ */
+function collect_return_type(func_node, func_scope, RS) {
+    const types = new Set();
+    // Use a plain visitor object (same pattern as ScopeBuilder): _visit(node, descend)
+    // receives the node and a closure that walks its children; call descend() to recurse.
+    func_node.walk({
+        _visit: function (node, descend) {
+            // Stop descent into nested functions — their returns are not ours.
+            if (node !== func_node && node instanceof RS.AST_Lambda) return;
+            if (node instanceof RS.AST_Return && node.value) {
+                const t = infer_expr_type(node.value, func_scope, RS);
+                if (t) types.add(t);
+            }
+            if (descend) descend();  // recurse into children
+        },
+    });
+    return types.size === 1 ? [...types][0] : null;
+}
+
+/**
+ * Extract the return type annotation from a function node as a normalized string.
+ * Maps `-> [X]` to 'list', `-> {k: v}` to 'dict', `-> str` to 'str', etc.
+ * Returns null if no annotation or unrecognised shape.
+ * @param {object} func_node
+ * @param {object} RS
+ * @returns {string|null}
+ */
+function extract_return_type(func_node, RS) {
+    const ann = func_node.return_annotation;
+    if (!ann) return null;
+    if (ann instanceof RS.AST_Array) return 'list';
+    if (ann instanceof RS.AST_Object) return 'dict';
+    if (ann instanceof RS.AST_SymbolRef ||
+        (RS.AST_SymbolVar && ann instanceof RS.AST_SymbolVar)) {
+        const n = ann.name;
+        if (n === 'str' || n === 'string') return 'str';
+        if (n === 'int' || n === 'float' || n === 'number') return 'number';
+        if (n === 'bool' || n === 'boolean') return 'bool';
+        return n;  // user-defined class name or 'list'/'dict' spelled out
+    }
+    return null;
+}
+
 /**
  * Collect parameter descriptors from an AST_Lambda node.
  * Handles regular args, positional-only (/), keyword-only (*), *args, and **kwargs.
@@ -94,10 +183,11 @@ function extract_params(lambda_node) {
 
 class ScopeBuilder {
     constructor(RS, map) {
-        this._RS          = RS;
-        this._map         = map;
-        this._scopes      = [];   // stack of ScopeFrame
-        this.current_node = null;
+        this._RS                  = RS;
+        this._map                 = map;
+        this._scopes              = [];   // stack of ScopeFrame
+        this.current_node         = null;
+        this._current_from_module = null; // set while inside an AST_Import with argnames
     }
 
     _current_scope() {
@@ -143,6 +233,9 @@ class ScopeBuilder {
             params:         opts.params         || null,
             inferred_class: opts.inferred_class || null,
             dts_call_path:  opts.dts_call_path  || null,
+            return_type:    opts.return_type    || null,
+            source_module:  opts.source_module  || null,
+            original_name:  opts.original_name  || null,
         });
         scope.addSymbol(sym);
         return sym;
@@ -176,6 +269,7 @@ class ScopeBuilder {
                         scope_depth: parent.depth,
                         doc:         extract_doc(node),
                         params:      extract_params(node),
+                        return_type: extract_return_type(node, RS),
                     });
                     parent.addSymbol(sym);
                 }
@@ -239,18 +333,28 @@ class ScopeBuilder {
                 defined_at: pos_from_token(node.start),
             });
 
+        } else if (node instanceof RS.AST_Import && node.argnames) {
+            // `from X import name [as alias], ...` — record module name so children can use it.
+            const mod_node = node.module;
+            this._current_from_module = mod_node
+                ? (mod_node.name || mod_node.value || null)
+                : null;
+
         } else if (node instanceof RS.AST_ImportedVar) {
             // `from X import name` or `from X import name as alias`
-            const name = (node.alias && node.alias.name) ? node.alias.name : node.name;
-            if (name) {
+            const alias = (node.alias && node.alias.name) ? node.alias.name : node.name;
+            if (alias) {
                 this._add_symbol({
-                    name,
-                    kind:       'import',
-                    defined_at: pos_from_token(node.start),
+                    name:          alias,
+                    kind:          'import',
+                    defined_at:    pos_from_token(node.start),
+                    source_module: this._current_from_module || null,
+                    original_name: (node.name !== alias) ? node.name : null,
                 });
             }
 
         } else if (node instanceof RS.AST_Import && !node.argnames) {
+            this._current_from_module = null;
             // `import X` or `import X as Y` (no from-clause)
             const name = (node.alias && node.alias.name)
                 ? node.alias.name
@@ -456,6 +560,24 @@ class ScopeBuilder {
 
         if (cont) cont();
 
+        // ------------------------------------------------------------------
+        // 3b. Post-traversal: infer return type for unannotated functions.
+        //     The function's own scope is fully populated at this point, so
+        //     local variable inferred_class values are available for lookup.
+        // ------------------------------------------------------------------
+
+        if (node instanceof RS.AST_Lambda && this._scopes.length > prev_depth) {
+            const func_scope   = this._current_scope();
+            const parent_frame = func_scope ? func_scope.parent : null;
+            const fname        = node.name ? node.name.name : null;
+            if (fname && parent_frame) {
+                const sym = parent_frame.getSymbol(fname);
+                if (sym && !sym.return_type) {
+                    sym.return_type = collect_return_type(node, func_scope, RS);
+                }
+            }
+        }
+
         // ------------------------------------------------------------------
         // 4. Pop the scope we pushed (if any).
         // ------------------------------------------------------------------

package/src/monaco-language-service/builtins.js

@@ -104,6 +104,11 @@ const STUBS = [
         return_type: 'iterable',
         doc: 'Return an iterator of elements from iterable for which function returns true.' }),
 
+    new BuiltinInfo({ name: 'format',
+        params: [p('value'), p('spec', { type: 'str', optional: true })],
+        return_type: 'str',
+        doc: 'Return value formatted according to the format spec string.\n\nEquivalent to calling `value.__format__(spec)` or applying spec as a `str.format()` format-spec field. The spec mini-language is the same as what follows `:` in f-strings and `str.format()` fields: alignment (`<>^=`), sign (`+-`), width, grouping (`,_`), precision (`.N`), and type (`bcdoxXeEfFgGns%`).\n\nExamples:\n\n    format(42, \'08b\')    # \'00101010\'\n    format(3.14, \'.2f\')  # \'3.14\'\n    format(\'hi\', \'>10\')  # \'        hi\'\n    format(42)           # \'42\'' }),
+
     new BuiltinInfo({ name: 'float', kind: 'class',
         params: [p('x', { optional: true })],
         return_type: 'float',
@@ -150,9 +155,9 @@ const STUBS = [
         doc: 'Return True if cls is a subclass of classinfo. classinfo may be a class or tuple of classes.' }),
 
     new BuiltinInfo({ name: 'iter',
-        params: [p('obj')],
+        params: [p('obj'), p('sentinel', { optional: true })],
         return_type: 'iterator',
-        doc: 'Return an iterator object for obj.' }),
+        doc: 'iter(iterable) → iterator over iterable. iter(callable, sentinel) → calls callable repeatedly until it returns sentinel.' }),
 
     new BuiltinInfo({ name: 'len',
         params: [p('s')],
@@ -164,6 +169,11 @@ const STUBS = [
         return_type: 'list',
         doc: 'Create a list from an iterable, or an empty list.' }),
 
+    new BuiltinInfo({ name: 'next',
+        params: [p('iterator'), p('default', { optional: true })],
+        return_type: 'any',
+        doc: 'Retrieve the next item from an iterator. If the iterator is exhausted, return default; if default is not given, raise StopIteration.' }),
+
     new BuiltinInfo({ name: 'map',
         params: [p('function'), p('iterable'), p('*iterables', { rest: true })],
         return_type: 'iterable',
@@ -219,6 +229,11 @@ const STUBS = [
         return_type: 'set',
         doc: 'Create a new set, optionally populated from an iterable.' }),
 
+    new BuiltinInfo({ name: 'slice', kind: 'class',
+        params: [p('start_or_stop', { type: 'int' }), p('stop', { type: 'int', optional: true }), p('step', { type: 'int', optional: true })],
+        return_type: 'slice',
+        doc: 'Create a slice object representing the set of indices specified by range(start, stop, step).\n\nForms:\n- `slice(stop)` — equivalent to `slice(None, stop, None)`\n- `slice(start, stop)` — equivalent to `slice(start, stop, None)`\n- `slice(start, stop, step)` — full form\n\nAttributes: `.start`, `.stop`, `.step` (each may be `None`).\n\nMethod: `.indices(length)` — returns `(start, stop, step)` normalized for a sequence of the given length.\n\nExample:\n\n    s = slice(1, 5)\n    lst[s]         # same as lst[1:5]\n    s.indices(10)  # (1, 5, 1)' }),
+
     new BuiltinInfo({ name: 'setattr',
         params: [p('obj'), p('name', { type: 'str' }), p('value')],
         return_type: 'None',