jslike 1.4.5 → 1.6.0

package/dist/esm/index.js

@@ -98,34 +98,59 @@ function containsTopLevelAwait(node) {
 }
 
 export async function execute(code, env = null, options = {}) {
-  // Parse the code
-  const ast = parse(code, options);
+  // Get execution controller if provided
+  const controller = options.executionController;
 
-  // Create global environment if not provided
-  if (!env) {
-    env = createGlobalEnvironment(new Environment());
+  // Mark execution as starting
+  if (controller) {
+    controller._start();
   }
 
-  // Create interpreter with module resolver and abort signal if provided
-  const interpreter = new Interpreter(env, {
-    moduleResolver: options.moduleResolver,
-    abortSignal: options.abortSignal
-  });
-
-  // Use async evaluation if:
-  // 1. Explicitly requested module mode
-  // 2. AST contains import/export declarations
-  // 3. Code contains top-level await
-  const needsAsync = options.sourceType === 'module' ||
-                     containsModuleDeclarations(ast) ||
-                     containsTopLevelAwait(ast);
-
-  if (needsAsync) {
-    const result = await interpreter.evaluateAsync(ast, env);
-    return result instanceof ReturnValue ? result.value : result;
-  } else {
-    const result = interpreter.evaluate(ast, env);
-    return result instanceof ReturnValue ? result.value : result;
+  try {
+    // Parse the code
+    const ast = parse(code, options);
+
+    // Create global environment if not provided
+    if (!env) {
+      env = createGlobalEnvironment(new Environment());
+    }
+
+    // Create interpreter with module resolver, abort signal, and execution controller
+    const interpreter = new Interpreter(env, {
+      moduleResolver: options.moduleResolver,
+      abortSignal: options.abortSignal,
+      executionController: controller
+    });
+
+    // Use async evaluation if:
+    // 1. Explicitly requested module mode
+    // 2. AST contains import/export declarations
+    // 3. Code contains top-level await
+    // 4. Execution controller provided (needs async for pause/resume)
+    const needsAsync = options.sourceType === 'module' ||
+                       containsModuleDeclarations(ast) ||
+                       containsTopLevelAwait(ast) ||
+                       controller != null;
+
+    if (needsAsync) {
+      const result = await interpreter.evaluateAsync(ast, env);
+      if (controller) {
+        controller._complete();
+      }
+      return result instanceof ReturnValue ? result.value : result;
+    } else {
+      const result = interpreter.evaluate(ast, env);
+      if (controller) {
+        controller._complete();
+      }
+      return result instanceof ReturnValue ? result.value : result;
+    }
+  } catch (e) {
+    // Mark as aborted if that's the error type
+    if (controller && e.name === 'AbortError') {
+      controller.state = 'aborted';
+    }
+    throw e;
   }
 }
 
@@ -139,6 +164,7 @@ export const isTopLevelAwait = containsModuleSyntax;
 export { Interpreter } from './interpreter/interpreter.js';
 export { Environment } from './runtime/environment.js';
 export { WangInterpreter, InMemoryModuleResolver } from './interpreter/index.js';
+export { ExecutionController } from './runtime/execution-controller.js';
 
 /**
  * Abstract base class for module resolution

package/dist/esm/interpreter/index.js

@@ -101,7 +101,8 @@ export class WangInterpreter {
 
     // Prepare execution options
     const options = {
-      moduleResolver: this.moduleResolver
+      moduleResolver: this.moduleResolver,
+      executionController: userOptions.executionController
       // sourceType will be auto-detected from code
     };
 

package/dist/esm/interpreter/interpreter.js

@@ -9,10 +9,17 @@ export class Interpreter {
     this.moduleCache = new Map();  // Cache loaded modules
     this.moduleExports = {};  // Track exports in current module
     this.abortSignal = options.abortSignal;
+    this.executionController = options.executionController;
   }
 
-  // Check if execution should be aborted
+  // Check if execution should be aborted (sync version)
   checkAbortSignal() {
+    // Check controller first if available
+    if (this.executionController) {
+      this.executionController._checkAbortSync();
+      return;
+    }
+    // Fall back to legacy abortSignal
     if (this.abortSignal && this.abortSignal.aborted) {
       const error = new Error('The operation was aborted');
       error.name = 'AbortError';
@@ -20,12 +27,26 @@ export class Interpreter {
     }
   }
 
+  // Checkpoint that returns a promise only when controller is present
+  // When no controller, returns null to signal no await needed
+  _getCheckpointPromise(node, env) {
+    if (this.executionController) {
+      this.executionController._setEnv(env);
+      return this.executionController._checkpoint(node);
+    } else {
+      this.checkAbortSignal();
+      return null;  // Signal that no await is needed
+    }
+  }
+
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return undefined;
 
-    // Check for abort signal before evaluating
-    this.checkAbortSignal();
+    // Checkpoint - yields if paused, throws if aborted
+    // Only await when there's actually a promise (controller present)
+    const checkpointPromise = this._getCheckpointPromise(node, env);
+    if (checkpointPromise) await checkpointPromise;
 
     // Handle await expressions by actually awaiting the promise
     if (node.type === 'AwaitExpression') {
@@ -262,6 +283,9 @@ export class Interpreter {
         await this.evaluateAsync(node.init, forEnv);
       }
       while (!node.test || await this.evaluateAsync(node.test, forEnv)) {
+        // Checkpoint at each loop iteration (only await if controller present)
+        const cp1 = this._getCheckpointPromise(node, forEnv);
+        if (cp1) await cp1;
         const result = await this.evaluateAsync(node.body, forEnv);
         if (result instanceof BreakSignal) {
           break;
@@ -290,6 +314,9 @@ export class Interpreter {
       const isConst = node.left.kind === 'const';
 
       for (const value of iterable) {
+        // Checkpoint at each loop iteration (only await if controller present)
+        const cp2 = this._getCheckpointPromise(node, forEnv);
+        if (cp2) await cp2;
         const iterEnv = forEnv.extend();
         if (declarator.id.type === 'Identifier') {
           iterEnv.define(declarator.id.name, value, isConst);
@@ -323,6 +350,9 @@ export class Interpreter {
       forEnv.define(varName, undefined);
 
       for (const key in obj) {
+        // Checkpoint at each loop iteration (only await if controller present)
+        const cp3 = this._getCheckpointPromise(node, forEnv);
+        if (cp3) await cp3;
         forEnv.set(varName, key);
         const result = await this.evaluateAsync(node.body, forEnv);
         if (result instanceof BreakSignal) {
@@ -341,6 +371,9 @@ export class Interpreter {
     // For WhileStatement with async body
     if (node.type === 'WhileStatement') {
       while (await this.evaluateAsync(node.test, env)) {
+        // Checkpoint at each loop iteration (only await if controller present)
+        const cp4 = this._getCheckpointPromise(node, env);
+        if (cp4) await cp4;
         const result = await this.evaluateAsync(node.body, env);
         if (result instanceof BreakSignal) {
           break;
@@ -358,6 +391,9 @@ export class Interpreter {
     // For DoWhileStatement with async body
     if (node.type === 'DoWhileStatement') {
       do {
+        // Checkpoint at each loop iteration (only await if controller present)
+        const cp5 = this._getCheckpointPromise(node, env);
+        if (cp5) await cp5;
         const result = await this.evaluateAsync(node.body, env);
         if (result instanceof BreakSignal) {
           break;
@@ -600,6 +636,26 @@ export class Interpreter {
       return this.evaluateClassExpression(node, env);
     }
 
+    // JSX Support (async)
+    if (node.type === 'JSXElement') {
+      return await this.evaluateJSXElementAsync(node, env);
+    }
+
+    if (node.type === 'JSXFragment') {
+      return await this.evaluateJSXFragmentAsync(node, env);
+    }
+
+    if (node.type === 'JSXExpressionContainer') {
+      if (node.expression.type === 'JSXEmptyExpression') {
+        return undefined;
+      }
+      return await this.evaluateAsync(node.expression, env);
+    }
+
+    if (node.type === 'JSXText') {
+      return this.normalizeJSXText(node.value);
+    }
+
     // Only leaf nodes should fall through to sync evaluate
     // These have no sub-expressions that could contain await
     if (['Literal', 'Identifier', 'BreakStatement', 'ContinueStatement',
@@ -774,6 +830,22 @@ export class Interpreter {
       case 'Property':
         return this.evaluateProperty(node, env);
 
+      // JSX Support
+      case 'JSXElement':
+        return this.evaluateJSXElement(node, env);
+
+      case 'JSXFragment':
+        return this.evaluateJSXFragment(node, env);
+
+      case 'JSXExpressionContainer':
+        if (node.expression.type === 'JSXEmptyExpression') {
+          return undefined;
+        }
+        return this.evaluate(node.expression, env);
+
+      case 'JSXText':
+        return this.normalizeJSXText(node.value);
+
       default:
         throw new Error(`Unknown node type: ${node.type}`);
     }
@@ -1161,6 +1233,9 @@ export class Interpreter {
     const metadata = func.__metadata || func;
     const funcEnv = new Environment(metadata.closure);
 
+    // Get function name for call stack tracking
+    const funcName = metadata.name || func.name || 'anonymous';
+
     // Bind 'this' if provided (for method calls)
     if (thisContext !== undefined) {
       funcEnv.define('this', thisContext);
@@ -1196,18 +1271,54 @@ export class Interpreter {
     // Execute function body
     // If async, use async evaluation and return a promise
     if (metadata.async) {
+      // Track call stack for async functions
+      if (this.executionController) {
+        this.executionController._pushCall(funcName);
+      }
       return (async () => {
+        try {
+          if (metadata.expression) {
+            // Arrow function with expression body
+            const result = await this.evaluateAsync(metadata.body, funcEnv);
+            // If the result is a ThrowSignal, throw the error
+            if (result instanceof ThrowSignal) {
+              throw result.value;
+            }
+            return result;
+          } else {
+            // Block statement body
+            const result = await this.evaluateAsync(metadata.body, funcEnv);
+            if (result instanceof ReturnValue) {
+              return result.value;
+            }
+            // If the result is a ThrowSignal, throw the error
+            if (result instanceof ThrowSignal) {
+              throw result.value;
+            }
+            return undefined;
+          }
+        } finally {
+          if (this.executionController) {
+            this.executionController._popCall();
+          }
+        }
+      })();
+    } else {
+      // Synchronous evaluation for non-async functions
+      // Track call stack for sync functions
+      if (this.executionController) {
+        this.executionController._pushCall(funcName);
+      }
+      try {
         if (metadata.expression) {
-          // Arrow function with expression body
-          const result = await this.evaluateAsync(metadata.body, funcEnv);
+          const result = this.evaluate(metadata.body, funcEnv);
           // If the result is a ThrowSignal, throw the error
           if (result instanceof ThrowSignal) {
             throw result.value;
           }
           return result;
         } else {
-          // Block statement body
-          const result = await this.evaluateAsync(metadata.body, funcEnv);
+          const result = this.evaluate(metadata.body, funcEnv);
           if (result instanceof ReturnValue) {
             return result.value;
           }
@@ -1217,26 +1328,10 @@ export class Interpreter {
           }
           return undefined;
         }
-      })();
-    } else {
-      // Synchronous evaluation for non-async functions
-      if (metadata.expression) {
-        const result = this.evaluate(metadata.body, funcEnv);
-        // If the result is a ThrowSignal, throw the error
-        if (result instanceof ThrowSignal) {
-          throw result.value;
-        }
-        return result;
-      } else {
-        const result = this.evaluate(metadata.body, funcEnv);
-        if (result instanceof ReturnValue) {
-          return result.value;
-        }
-        // If the result is a ThrowSignal, throw the error
-        if (result instanceof ThrowSignal) {
-          throw result.value;
+      } finally {
+        if (this.executionController) {
+          this.executionController._popCall();
         }
-        return undefined;
       }
     }
   }
@@ -2175,4 +2270,253 @@ export class Interpreter {
     // Already handled in evaluateObjectExpression
     return undefined;
   }
+
+  // ===== JSX Support =====
+
+  evaluateJSXElement(node, env) {
+    const createElement = this.getCreateElement(env);
+    const { type, props } = this.evaluateJSXOpeningElement(node.openingElement, env);
+    const children = this.evaluateJSXChildren(node.children, env);
+
+    if (children.length === 0) {
+      return createElement(type, props);
+    } else if (children.length === 1) {
+      return createElement(type, props, children[0]);
+    }
+    return createElement(type, props, ...children);
+  }
+
+  evaluateJSXFragment(node, env) {
+    const createElement = this.getCreateElement(env);
+    const Fragment = this.getFragment(env);
+    const children = this.evaluateJSXChildren(node.children, env);
+
+    if (children.length === 0) {
+      return createElement(Fragment, null);
+    } else if (children.length === 1) {
+      return createElement(Fragment, null, children[0]);
+    }
+    return createElement(Fragment, null, ...children);
+  }
+
+  evaluateJSXOpeningElement(node, env) {
+    const type = this.evaluateJSXElementName(node.name, env);
+    const props = {};
+
+    for (const attr of node.attributes) {
+      if (attr.type === 'JSXAttribute') {
+        const name = attr.name.type === 'JSXIdentifier'
+          ? attr.name.name
+          : `${attr.name.namespace.name}:${attr.name.name.name}`;
+        const value = attr.value
+          ? this.evaluateJSXAttributeValue(attr.value, env)
+          : true;
+        props[name] = value;
+      } else if (attr.type === 'JSXSpreadAttribute') {
+        Object.assign(props, this.evaluate(attr.argument, env));
+      }
+    }
+
+    return { type, props: Object.keys(props).length > 0 ? props : null };
+  }
+
+  evaluateJSXElementName(node, env) {
+    if (node.type === 'JSXIdentifier') {
+      const name = node.name;
+      // Lowercase = intrinsic ('div'), Uppercase = component
+      if (name[0] === name[0].toLowerCase()) {
+        return name;
+      }
+      return env.get(name);
+    } else if (node.type === 'JSXMemberExpression') {
+      const object = this.evaluateJSXElementName(node.object, env);
+      return object[node.property.name];
+    } else if (node.type === 'JSXNamespacedName') {
+      return `${node.namespace.name}:${node.name.name}`;
+    }
+    throw new Error(`Unknown JSX element name type: ${node.type}`);
+  }
+
+  evaluateJSXAttributeValue(node, env) {
+    if (node.type === 'Literal') return node.value;
+    if (node.type === 'JSXExpressionContainer') {
+      return this.evaluate(node.expression, env);
+    }
+    if (node.type === 'JSXElement') return this.evaluateJSXElement(node, env);
+    if (node.type === 'JSXFragment') return this.evaluateJSXFragment(node, env);
+    throw new Error(`Unknown JSX attribute value type: ${node.type}`);
+  }
+
+  evaluateJSXChildren(children, env) {
+    const result = [];
+    for (const child of children) {
+      if (child.type === 'JSXText') {
+        const text = this.normalizeJSXText(child.value);
+        if (text) result.push(text);
+      } else if (child.type === 'JSXExpressionContainer') {
+        if (child.expression.type !== 'JSXEmptyExpression') {
+          const value = this.evaluate(child.expression, env);
+          if (Array.isArray(value)) {
+            result.push(...value);
+          } else if (value !== null && value !== undefined && value !== false) {
+            result.push(value);
+          }
+        }
+      } else if (child.type === 'JSXElement') {
+        result.push(this.evaluateJSXElement(child, env));
+      } else if (child.type === 'JSXFragment') {
+        result.push(this.evaluateJSXFragment(child, env));
+      }
+    }
+    return result;
+  }
+
+  normalizeJSXText(text) {
+    // React's JSX whitespace normalization
+    const lines = text.split('\n');
+    const normalized = lines
+      .map((line, i) => {
+        let result = line;
+        if (i === 0) result = result.trimStart();
+        if (i === lines.length - 1) result = result.trimEnd();
+        return result;
+      })
+      .filter(line => line.length > 0)
+      .join(' ');
+    return normalized || null;
+  }
+
+  getCreateElement(env) {
+    // Try React.createElement first
+    try {
+      const React = env.get('React');
+      if (React && React.createElement) {
+        return React.createElement.bind(React);
+      }
+    } catch (e) { /* not defined */ }
+
+    // Try standalone createElement
+    try {
+      return env.get('createElement');
+    } catch (e) { /* not defined */ }
+
+    // Fallback: simple element factory for non-React usage
+    return (type, props, ...children) => ({
+      $$typeof: Symbol.for('react.element'),
+      type,
+      props: {
+        ...props,
+        children: children.length === 0 ? undefined : children.length === 1 ? children[0] : children
+      },
+      key: props?.key ?? null,
+      ref: props?.ref ?? null
+    });
+  }
+
+  getFragment(env) {
+    // Try React.Fragment
+    try {
+      const React = env.get('React');
+      if (React && React.Fragment) {
+        return React.Fragment;
+      }
+    } catch (e) { /* not defined */ }
+
+    // Try standalone Fragment
+    try {
+      return env.get('Fragment');
+    } catch (e) { /* not defined */ }
+
+    // Fallback: Symbol for fragments
+    return Symbol.for('react.fragment');
+  }
+
+  // ===== Async JSX Support =====
+
+  async evaluateJSXElementAsync(node, env) {
+    const checkpointPromise = this._getCheckpointPromise(node, env);
+    if (checkpointPromise) await checkpointPromise;
+
+    const createElement = this.getCreateElement(env);
+    const { type, props } = await this.evaluateJSXOpeningElementAsync(node.openingElement, env);
+    const children = await this.evaluateJSXChildrenAsync(node.children, env);
+
+    if (children.length === 0) {
+      return createElement(type, props);
+    } else if (children.length === 1) {
+      return createElement(type, props, children[0]);
+    }
+    return createElement(type, props, ...children);
+  }
+
+  async evaluateJSXFragmentAsync(node, env) {
+    const checkpointPromise = this._getCheckpointPromise(node, env);
+    if (checkpointPromise) await checkpointPromise;
+
+    const createElement = this.getCreateElement(env);
+    const Fragment = this.getFragment(env);
+    const children = await this.evaluateJSXChildrenAsync(node.children, env);
+
+    if (children.length === 0) {
+      return createElement(Fragment, null);
+    } else if (children.length === 1) {
+      return createElement(Fragment, null, children[0]);
+    }
+    return createElement(Fragment, null, ...children);
+  }
+
+  async evaluateJSXOpeningElementAsync(node, env) {
+    const type = this.evaluateJSXElementName(node.name, env);
+    const props = {};
+
+    for (const attr of node.attributes) {
+      if (attr.type === 'JSXAttribute') {
+        const name = attr.name.type === 'JSXIdentifier'
+          ? attr.name.name
+          : `${attr.name.namespace.name}:${attr.name.name.name}`;
+        const value = attr.value
+          ? await this.evaluateJSXAttributeValueAsync(attr.value, env)
+          : true;
+        props[name] = value;
+      } else if (attr.type === 'JSXSpreadAttribute') {
+        Object.assign(props, await this.evaluateAsync(attr.argument, env));
+      }
+    }
+
+    return { type, props: Object.keys(props).length > 0 ? props : null };
+  }
+
+  async evaluateJSXAttributeValueAsync(node, env) {
+    if (node.type === 'Literal') return node.value;
+    if (node.type === 'JSXExpressionContainer') {
+      return await this.evaluateAsync(node.expression, env);
+    }
+    if (node.type === 'JSXElement') return await this.evaluateJSXElementAsync(node, env);
+    if (node.type === 'JSXFragment') return await this.evaluateJSXFragmentAsync(node, env);
+    throw new Error(`Unknown JSX attribute value type: ${node.type}`);
+  }
+
+  async evaluateJSXChildrenAsync(children, env) {
+    const result = [];
+    for (const child of children) {
+      if (child.type === 'JSXText') {
+        const text = this.normalizeJSXText(child.value);
+        if (text) result.push(text);
+      } else if (child.type === 'JSXExpressionContainer') {
+        if (child.expression.type !== 'JSXEmptyExpression') {
+          const value = await this.evaluateAsync(child.expression, env);
+          if (Array.isArray(value)) {
+            result.push(...value);
+          } else if (value !== null && value !== undefined && value !== false) {
+            result.push(value);
+          }
+        }
+      } else if (child.type === 'JSXElement') {
+        result.push(await this.evaluateJSXElementAsync(child, env));
+      } else if (child.type === 'JSXFragment') {
+        result.push(await this.evaluateJSXFragmentAsync(child, env));
+      }
+    }
+    return result;
+  }
 }