jslike 1.7.2 → 1.8.0

package/README.md

@@ -473,7 +473,10 @@ Execute JavaScript code and return the result.
 const result = await execute(code, env, {
   moduleResolver,        // For import statements
   executionController,   // For pause/resume/abort
-  abortSignal            // For cancellation
+  abortSignal,           // For cancellation
+  sourcePath,            // Optional importer path for resolving top-level imports
+  typescript,            // Parse TypeScript syntax
+  tsx                    // Parse TypeScript + JSX syntax
 });
 ```
 

package/dist/esm/index.js

@@ -1,5 +1,5 @@
 // Use bundled Acorn parser for zero runtime dependencies
-import { parse as acornParse } from './parser.js';
+import { parse as acornParse, tsParse, tsxParse } from './parser.js';
 import { Interpreter } from './interpreter/interpreter.js';
 import { Environment, ReturnValue } from './runtime/environment.js';
 import { createGlobalEnvironment } from './runtime/builtins.js';
@@ -9,7 +9,7 @@ function containsModuleSyntax(code) {
   // Trigger module mode for:
   // 1. import/export statements
   // 2. Top-level await (await not inside a function)
-  if (/^\s*(import|export)\s+/m.test(code)) {
+  if (/(^|[;{\n])\s*(import|export)\s+/m.test(code)) {
     return true;
   }
 
@@ -23,6 +23,13 @@ function containsModuleSyntax(code) {
   return false;
 }
 
+function isTypeScriptPath(sourcePath) {
+  return typeof sourcePath === 'string' && /\.(ts|tsx|mts|cts)$/i.test(sourcePath);
+}
+
+function isTSXPath(sourcePath) {
+  return typeof sourcePath === 'string' && /\.tsx$/i.test(sourcePath);
+}
 
 export function parse(code, options = {}) {
   // Determine sourceType: use 'module' ONLY if explicitly requested or if code has imports/exports
@@ -32,10 +39,13 @@ export function parse(code, options = {}) {
     sourceType = 'module';
   }
 
+  const shouldParseTypeScript = options.typescript || options.tsx || isTypeScriptPath(options.sourcePath);
+  const parser = options.tsx || isTSXPath(options.sourcePath) ? tsxParse : shouldParseTypeScript ? tsParse : acornParse;
+
   // Parse with Acorn
   try {
-    return acornParse(code, {
-      ecmaVersion: 2022,  // Support ES2022 features (including top-level await)
+    return parser(code, {
+      ecmaVersion: shouldParseTypeScript ? 'latest' : 2022,  // Support ES2022 features (including top-level await)
       sourceType: sourceType,
       locations: true,     // Track source locations for better error messages
       allowReturnOutsideFunction: true,  // Allow top-level return statements
@@ -119,7 +129,8 @@ export async function execute(code, env = null, options = {}) {
     const interpreter = new Interpreter(env, {
       moduleResolver: options.moduleResolver,
       abortSignal: options.abortSignal,
-      executionController: controller
+      executionController: controller,
+      currentModulePath: options.sourcePath
     });
 
     // Use async evaluation if:

package/dist/esm/interpreter/index.js

@@ -103,7 +103,8 @@ export class WangInterpreter {
     const options = {
       moduleResolver: this.moduleResolver,
       executionController: userOptions.executionController,
-      abortSignal: userOptions.abortSignal  // Pass abort signal to interpreter for cancellation support
+      abortSignal: userOptions.abortSignal,  // Pass abort signal to interpreter for cancellation support
+      sourcePath: userOptions.sourcePath ?? this.options.sourcePath
       // sourceType will be auto-detected from code
     };
 

package/dist/esm/interpreter/interpreter.js

@@ -1,13 +1,70 @@
 import { Environment, ReturnValue, BreakSignal, ContinueSignal, ThrowSignal } from '../runtime/environment.js';
-import { parse as acornParse } from '../parser.js';
+import { parse as acornParse, tsParse, tsxParse } from '../parser.js';
 import { createMethodNotFoundError } from '../errors/enhanced-error.js';
 
+function isTypeScriptPath(sourcePath) {
+  return typeof sourcePath === 'string' && /\.(ts|tsx|mts|cts)$/i.test(sourcePath);
+}
+
+function isTSXPath(sourcePath) {
+  return typeof sourcePath === 'string' && /\.tsx$/i.test(sourcePath);
+}
+
+function parseModuleCode(code, sourcePath) {
+  const parser = isTSXPath(sourcePath) ? tsxParse : isTypeScriptPath(sourcePath) ? tsParse : acornParse;
+  return parser(code, {
+    ecmaVersion: isTypeScriptPath(sourcePath) ? 'latest' : 2020,
+    sourceType: 'module',
+    locations: isTypeScriptPath(sourcePath)
+  });
+}
+
+const TYPE_ONLY_DECLARATIONS = new Set([
+  'TSTypeAliasDeclaration',
+  'TSInterfaceDeclaration',
+  'TSDeclareFunction'
+]);
+
+const TYPE_WRAPPER_EXPRESSIONS = new Set([
+  'TSAsExpression',
+  'TSTypeAssertion',
+  'TSNonNullExpression',
+  'TSSatisfiesExpression',
+  'TSInstantiationExpression'
+]);
+
+function isTypeOnlyDeclaration(node) {
+  return TYPE_ONLY_DECLARATIONS.has(node?.type) || node?.declare === true;
+}
+
+function isTypeWrapperExpression(node) {
+  return TYPE_WRAPPER_EXPRESSIONS.has(node?.type);
+}
+
+function getTypeWrapperInnerExpression(node) {
+  return node.expression;
+}
+
+function createUnsupportedTypeScriptRuntimeError(node) {
+  return new Error(`Unsupported runtime TypeScript syntax: ${node.type}`);
+}
+
+function getPatternName(pattern) {
+  if (!pattern) return undefined;
+  if (pattern.type === 'Identifier') return pattern.name;
+  if (pattern.type === 'AssignmentPattern') return getPatternName(pattern.left);
+  if (pattern.type === 'TSParameterProperty') return getPatternName(pattern.parameter);
+  return pattern.name;
+}
+
 export class Interpreter {
   constructor(globalEnv, options = {}) {
     this.globalEnv = globalEnv;
     this.moduleResolver = options.moduleResolver;
     this.moduleCache = new Map();  // Cache loaded modules
+    this.moduleResolutionCache = options.moduleResolutionCache || new Map();
     this.moduleExports = {};  // Track exports in current module
+    this.currentModulePath = options.currentModulePath;
     this.abortSignal = options.abortSignal;
     this.executionController = options.executionController;
   }
@@ -39,6 +96,121 @@ export class Interpreter {
     }
   }
 
+  async evaluateAsyncRawValue(node, env) {
+    if (!node) return { value: undefined };
+
+    if (node.type === 'CallExpression') {
+      return await this.evaluateCallExpressionAsyncRawValue(node, env);
+    }
+
+    if (node.type === 'MemberExpression') {
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
+
+      if (node.optional && (obj === null || obj === undefined)) {
+        return { value: undefined };
+      }
+
+      if (obj === null || obj === undefined) {
+        throw new TypeError(`Cannot read property of ${obj}`);
+      }
+
+      const prop = node.computed
+        ? await this.evaluateAsync(node.property, env)
+        : node.property.name;
+
+      return { value: obj[prop] };
+    }
+
+    if (node.type === 'ChainExpression') {
+      return await this.evaluateAsyncRawValue(node.expression, env);
+    }
+
+    if (node.type === 'ConditionalExpression') {
+      const test = await this.evaluateAsync(node.test, env);
+      return await this.evaluateAsyncRawValue(test ? node.consequent : node.alternate, env);
+    }
+
+    if (node.type === 'LogicalExpression') {
+      const left = await this.evaluateAsync(node.left, env);
+      if (node.operator === '&&') {
+        return left ? await this.evaluateAsyncRawValue(node.right, env) : { value: left };
+      }
+      if (node.operator === '||') {
+        return left ? { value: left } : await this.evaluateAsyncRawValue(node.right, env);
+      }
+      if (node.operator === '??') {
+        return left !== null && left !== undefined
+          ? { value: left }
+          : await this.evaluateAsyncRawValue(node.right, env);
+      }
+    }
+
+    if (node.type === 'SequenceExpression') {
+      for (let i = 0; i < node.expressions.length - 1; i++) {
+        await this.evaluateAsync(node.expressions[i], env);
+      }
+      return await this.evaluateAsyncRawValue(node.expressions[node.expressions.length - 1], env);
+    }
+
+    if (node.type === 'NewExpression') {
+      return { value: this.evaluateNewExpression(node, env) };
+    }
+
+    if (['Literal', 'Identifier', 'ThisExpression', 'Super'].includes(node.type)) {
+      return { value: this.evaluate(node, env) };
+    }
+
+    return { value: await this.evaluateAsync(node, env) };
+  }
+
+  async evaluateCallExpressionAsyncRawValue(node, env) {
+    let thisContext = undefined;
+    let callee;
+    let objectName = null;
+    let methodName = null;
+
+    if (node.callee.type === 'MemberExpression') {
+      thisContext = (await this.evaluateAsyncRawValue(node.callee.object, env)).value;
+      if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
+        return { value: undefined };
+      }
+      const prop = node.callee.computed
+        ? await this.evaluateAsync(node.callee.property, env)
+        : node.callee.property.name;
+      callee = thisContext[prop];
+
+      methodName = prop;
+      objectName = this.getExpressionName(node.callee.object);
+    } else {
+      callee = await this.evaluateAsync(node.callee, env);
+    }
+
+    if (node.optional && (callee === null || callee === undefined)) {
+      return { value: undefined };
+    }
+
+    const rawArgs = [];
+    for (const arg of node.arguments) {
+      rawArgs.push(await this.evaluateAsync(arg, env));
+    }
+    const args = this.flattenSpreadArgs(rawArgs);
+
+    if (typeof callee === 'function') {
+      const value = thisContext !== undefined
+        ? callee.call(thisContext, ...args)
+        : callee(...args);
+      return { value };
+    } else if (callee && callee.__isFunction) {
+      return { value: this.callUserFunction(callee, args, env, thisContext) };
+    }
+
+    if (objectName && methodName) {
+      throw createMethodNotFoundError(objectName, methodName, thisContext);
+    }
+
+    throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+  }
+
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return undefined;
@@ -48,6 +220,27 @@ export class Interpreter {
     const checkpointPromise = this._getCheckpointPromise(node, env);
     if (checkpointPromise) await checkpointPromise;
 
+    if (isTypeOnlyDeclaration(node)) {
+      return undefined;
+    }
+
+    if (node.type === 'TSExportAssignment' || node.type === 'TSImportEqualsDeclaration') {
+      throw createUnsupportedTypeScriptRuntimeError(node);
+    }
+
+    if (node.type === 'TSEnumDeclaration') {
+      return this.evaluateTSEnumDeclaration(node, env);
+    }
+
+    if (node.type === 'TSModuleDeclaration') {
+      if (node.declare) return undefined;
+      throw createUnsupportedTypeScriptRuntimeError(node);
+    }
+
+    if (isTypeWrapperExpression(node)) {
+      return await this.evaluateAsync(getTypeWrapperInnerExpression(node), env);
+    }
+
     // Handle await expressions by actually awaiting the promise
     if (node.type === 'AwaitExpression') {
       const promise = await this.evaluateAsync(node.argument, env);
@@ -77,7 +270,7 @@ export class Interpreter {
     if (node.type === 'VariableDeclaration') {
       for (const declarator of node.declarations) {
         const value = declarator.init
-          ? await this.evaluateAsync(declarator.init, env)
+          ? (await this.evaluateAsyncRawValue(declarator.init, env)).value
           : undefined;
 
         const isConst = node.kind === 'const';
@@ -134,54 +327,8 @@ export class Interpreter {
 
     // For call expressions (might be calling async functions)
     if (node.type === 'CallExpression') {
-      let thisContext = undefined;
-      let callee;
-      let objectName = null;
-      let methodName = null;
-
-      if (node.callee.type === 'MemberExpression') {
-        thisContext = await this.evaluateAsync(node.callee.object, env);
-        if (node.callee.optional && (thisContext === null || thisContext === undefined)) {
-          return undefined;
-        }
-        const prop = node.callee.computed
-          ? await this.evaluateAsync(node.callee.property, env)
-          : node.callee.property.name;
-        callee = thisContext[prop];
-
-        // Capture names for enhanced error messages
-        methodName = prop;
-        objectName = this.getExpressionName(node.callee.object);
-      } else {
-        callee = await this.evaluateAsync(node.callee, env);
-      }
-
-      // Handle optional call - if optional and callee is null/undefined, return undefined
-      if (node.optional && (callee === null || callee === undefined)) {
-        return undefined;
-      }
-
-      const rawArgs = [];
-      for (const arg of node.arguments) {
-        rawArgs.push(await this.evaluateAsync(arg, env));
-      }
-      const args = this.flattenSpreadArgs(rawArgs);
-
-      if (typeof callee === 'function') {
-        if (thisContext !== undefined) {
-          return await callee.call(thisContext, ...args);
-        }
-        return await callee(...args);
-      } else if (callee && callee.__isFunction) {
-        return await this.callUserFunction(callee, args, env, thisContext);
-      }
-
-      // Throw enhanced error for member expression calls
-      if (objectName && methodName) {
-        throw createMethodNotFoundError(objectName, methodName, thisContext);
-      }
-
-      throw new TypeError(`${node.callee.name || 'Expression'} is not a function`);
+      const result = (await this.evaluateCallExpressionAsyncRawValue(node, env)).value;
+      return await result;
     }
 
     // For chain expressions (optional chaining)
@@ -191,7 +338,7 @@ export class Interpreter {
 
     // For member expressions in async context
     if (node.type === 'MemberExpression') {
-      const obj = await this.evaluateAsync(node.object, env);
+      const obj = (await this.evaluateAsyncRawValue(node.object, env)).value;
 
       // Handle optional chaining
       if (node.optional && (obj === null || obj === undefined)) {
@@ -513,7 +660,7 @@ export class Interpreter {
 
     // For AssignmentExpression with async value
     if (node.type === 'AssignmentExpression') {
-      const value = await this.evaluateAsync(node.right, env);
+      const value = (await this.evaluateAsyncRawValue(node.right, env)).value;
 
       if (node.left.type === 'Identifier') {
         const name = node.left.name;
@@ -745,6 +892,27 @@ export class Interpreter {
     // Check for abort signal before evaluating
     this.checkAbortSignal();
 
+    if (isTypeOnlyDeclaration(node)) {
+      return undefined;
+    }
+
+    if (node.type === 'TSExportAssignment' || node.type === 'TSImportEqualsDeclaration') {
+      throw createUnsupportedTypeScriptRuntimeError(node);
+    }
+
+    if (node.type === 'TSEnumDeclaration') {
+      return this.evaluateTSEnumDeclaration(node, env);
+    }
+
+    if (node.type === 'TSModuleDeclaration') {
+      if (node.declare) return undefined;
+      throw createUnsupportedTypeScriptRuntimeError(node);
+    }
+
+    if (isTypeWrapperExpression(node)) {
+      return this.evaluate(getTypeWrapperInnerExpression(node), env);
+    }
+
     switch (node.type) {
       case 'Program':
         return this.evaluateProgram(node, env);
@@ -905,6 +1073,9 @@ export class Interpreter {
       case 'Property':
         return this.evaluateProperty(node, env);
 
+      case 'TSEnumDeclaration':
+        return this.evaluateTSEnumDeclaration(node, env);
+
       // JSX Support
       case 'JSXElement':
         return this.evaluateJSXElement(node, env);
@@ -1327,7 +1498,9 @@ export class Interpreter {
 
     // Bind parameters
     for (let i = 0; i < metadata.params.length; i++) {
-      const param = metadata.params[i];
+      const param = metadata.params[i].type === 'TSParameterProperty'
+        ? metadata.params[i].parameter
+        : metadata.params[i];
 
       if (param.type === 'Identifier') {
         // Simple parameter: function(x)
@@ -1650,6 +1823,34 @@ export class Interpreter {
     return undefined;
   }
 
+  evaluateTSEnumDeclaration(node, env) {
+    const enumObject = {};
+    let nextNumericValue = 0;
+
+    for (const member of node.members) {
+      const memberName = member.id.name ?? member.id.value;
+      let value;
+
+      if (member.initializer) {
+        value = this.evaluate(member.initializer, env);
+      } else {
+        value = nextNumericValue;
+      }
+
+      enumObject[memberName] = value;
+
+      if (typeof value === 'number') {
+        enumObject[value] = memberName;
+        nextNumericValue = value + 1;
+      } else {
+        nextNumericValue = undefined;
+      }
+    }
+
+    env.define(node.id.name, enumObject, false);
+    return undefined;
+  }
+
   bindObjectPattern(pattern, value, env, isConst = false) {
     if (value === null || value === undefined) {
       throw new TypeError('Cannot destructure undefined or null');
@@ -1754,42 +1955,65 @@ export class Interpreter {
     // Get module path from import source
     const modulePath = node.source.value;
 
+    if (node.importKind === 'type' ||
+        (node.specifiers.length > 0 && node.specifiers.every(specifier => specifier.importKind === 'type'))) {
+      return undefined;
+    }
+
     // Check if module resolver is configured
     if (!this.moduleResolver) {
       throw new Error('Module resolver not configured - cannot import modules');
     }
 
+    const fromPath = this.currentModulePath;
+
+    const resolutionCacheKey = `${fromPath || ''}\0${modulePath}`;
+    let resolution;
+    let resolvedPath = this.moduleResolutionCache.get(resolutionCacheKey);
+    if (!resolvedPath && !modulePath.startsWith('.') && this.moduleCache.has(modulePath)) {
+      resolvedPath = modulePath;
+    }
+
     // Check if module is already cached
     let moduleExports;
-    if (this.moduleCache.has(modulePath)) {
-      moduleExports = this.moduleCache.get(modulePath);
+    if (resolvedPath && this.moduleCache.has(resolvedPath)) {
+      moduleExports = this.moduleCache.get(resolvedPath);
     } else {
-      // Resolve and load module code
-      const resolution = await this.moduleResolver.resolve(modulePath);
+      // Resolve first so relative imports can use importer context and cache by resolved path.
+      resolution = await this.moduleResolver.resolve(modulePath, fromPath);
       if (!resolution) {
         throw new Error(`Cannot find module '${modulePath}'`);
       }
 
+      resolvedPath = typeof resolution === 'string'
+        ? modulePath
+        : resolution.path || modulePath;
+      this.moduleResolutionCache.set(resolutionCacheKey, resolvedPath);
+      if (this.moduleCache.has(resolvedPath)) {
+        moduleExports = this.moduleCache.get(resolvedPath);
+        return this.bindImportSpecifiers(node, env, modulePath, moduleExports);
+      }
+
       // Handle native module exports (for libraries like React)
       // If resolution has 'exports' property, use it directly without parsing
       if (resolution.exports) {
         moduleExports = resolution.exports;
-        this.moduleCache.set(modulePath, moduleExports);
+        this.moduleCache.set(resolvedPath, moduleExports);
       } else {
         // Handle both old (string) and new (ModuleResolution) formats
         const moduleCode = typeof resolution === 'string' ? resolution : resolution.code;
 
         // Parse and execute module in its own environment
-        const moduleAst = acornParse(moduleCode, {
-          ecmaVersion: 2020,
-          sourceType: 'module',
-          locations: false
-        });
+        const moduleAst = parseModuleCode(moduleCode, resolvedPath);
         const moduleEnv = new Environment(this.globalEnv);
 
         // Create a new interpreter for the module with shared module cache
         const moduleInterpreter = new Interpreter(this.globalEnv, {
-          moduleResolver: this.moduleResolver
+          moduleResolver: this.moduleResolver,
+          moduleResolutionCache: this.moduleResolutionCache,
+          currentModulePath: resolvedPath,
+          abortSignal: this.abortSignal,
+          executionController: this.executionController
         });
         moduleInterpreter.moduleCache = this.moduleCache;  // Share cache
 
@@ -1798,12 +2022,21 @@ export class Interpreter {
 
         // Cache the module exports
         moduleExports = moduleInterpreter.moduleExports;
-        this.moduleCache.set(modulePath, moduleExports);
+        this.moduleCache.set(resolvedPath, moduleExports);
       }
     }
 
+    this.bindImportSpecifiers(node, env, modulePath, moduleExports);
+    return undefined;
+  }
+
+  bindImportSpecifiers(node, env, modulePath, moduleExports) {
     // Import specified bindings into current environment
     for (const specifier of node.specifiers) {
+      if (specifier.importKind === 'type') {
+        continue;
+      }
+
       if (specifier.type === 'ImportSpecifier') {
         // Named import: import { foo, bar } from "module"
         const importedName = specifier.imported.name;
@@ -1834,6 +2067,10 @@ export class Interpreter {
   }
 
   evaluateExportNamedDeclaration(node, env) {
+    if (node.exportKind === 'type' || isTypeOnlyDeclaration(node.declaration)) {
+      return undefined;
+    }
+
     // Handle export with declaration: export function foo() {} or export const x = 42
     if (node.declaration) {
       const result = this.evaluate(node.declaration, env);
@@ -1853,6 +2090,9 @@ export class Interpreter {
         // export class Foo {}
         const name = node.declaration.id.name;
         this.moduleExports[name] = env.get(name);
+      } else if (node.declaration.type === 'TSEnumDeclaration') {
+        const name = node.declaration.id.name;
+        this.moduleExports[name] = env.get(name);
       }
 
       return result;
@@ -1861,6 +2101,10 @@ export class Interpreter {
     // Handle export list: export { foo, bar }
     if (node.specifiers && node.specifiers.length > 0) {
       for (const specifier of node.specifiers) {
+        if (specifier.exportKind === 'type') {
+          continue;
+        }
+
         const exportedName = specifier.exported.name;
         const localName = specifier.local.name;
         this.moduleExports[exportedName] = env.get(localName);
@@ -2337,7 +2581,10 @@ export class Interpreter {
 
     // Bind parameters
     for (let i = 0; i < methodFunc.__params.length; i++) {
-      const param = methodFunc.__params[i];
+      const originalParam = methodFunc.__params[i];
+      const param = originalParam.type === 'TSParameterProperty'
+        ? originalParam.parameter
+        : originalParam;
 
       if (param.type === 'Identifier') {
         // Simple parameter: function(x)
@@ -2360,6 +2607,13 @@ export class Interpreter {
         // Fallback for simple parameter names
         funcEnv.define(param.name, args[i]);
       }
+
+      if (originalParam.type === 'TSParameterProperty') {
+        const propertyName = getPatternName(originalParam.parameter);
+        if (propertyName) {
+          thisContext[propertyName] = funcEnv.get(propertyName);
+        }
+      }
     }
 
     const result = this.evaluate(methodFunc.__body, funcEnv);