jslike 1.7.3 → 1.8.1

package/dist/esm/interpreter/interpreter.js

@@ -1,13 +1,240 @@
 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;
+}
+
+function collectRuntimeIdentifierReferences(node) {
+  const references = new Set();
+  const skipKeys = new Set([
+    'type',
+    'start',
+    'end',
+    'loc',
+    'range',
+    'raw',
+    'typeAnnotation',
+    'returnType',
+    'typeParameters',
+    'typeArguments',
+    'implements'
+  ]);
+
+  const visitPatternDefaults = (pattern) => {
+    if (!pattern || typeof pattern !== 'object') return;
+    if (pattern.type === 'AssignmentPattern') {
+      visit(pattern.right);
+      visitPatternDefaults(pattern.left);
+    } else if (pattern.type === 'ObjectPattern') {
+      for (const property of pattern.properties || []) {
+        visitPatternDefaults(property.value || property.argument);
+      }
+    } else if (pattern.type === 'ArrayPattern') {
+      for (const element of pattern.elements || []) {
+        visitPatternDefaults(element);
+      }
+    } else if (pattern.type === 'RestElement') {
+      visitPatternDefaults(pattern.argument);
+    } else if (pattern.type === 'TSParameterProperty') {
+      visitPatternDefaults(pattern.parameter);
+    }
+  };
+
+  const visitFunction = (fn) => {
+    for (const param of fn.params || []) {
+      visitPatternDefaults(param);
+    }
+    visit(fn.body);
+  };
+
+  const visitJSXName = (jsxName) => {
+    if (!jsxName || typeof jsxName !== 'object') return;
+    if (jsxName.type === 'JSXIdentifier') {
+      if (/^[A-Z]/.test(jsxName.name)) {
+        references.add(jsxName.name);
+      }
+    } else if (jsxName.type === 'JSXMemberExpression') {
+      visitJSXName(jsxName.object);
+    } else if (jsxName.type === 'JSXNamespacedName') {
+      visitJSXName(jsxName.namespace);
+    }
+  };
+
+  const visit = (current, parent = null, parentKey = null) => {
+    if (!current || typeof current !== 'object') return;
+
+    if (Array.isArray(current)) {
+      for (const item of current) visit(item, parent, parentKey);
+      return;
+    }
+
+    if (current.type?.startsWith('TS')) {
+      if (isTypeWrapperExpression(current)) {
+        visit(getTypeWrapperInnerExpression(current), current, 'expression');
+      } else if (current.type === 'TSEnumDeclaration') {
+        for (const member of current.members || []) {
+          visit(member.initializer);
+        }
+      }
+      return;
+    }
+
+    switch (current.type) {
+      case 'Identifier':
+        references.add(current.name);
+        return;
+      case 'ImportDeclaration':
+        return;
+      case 'ExportNamedDeclaration':
+        if (current.declaration) {
+          visit(current.declaration, current, 'declaration');
+        } else if (current.exportKind !== 'type') {
+          for (const specifier of current.specifiers || []) {
+            if (specifier.exportKind !== 'type' && specifier.local?.name) {
+              references.add(specifier.local.name);
+            }
+          }
+        }
+        return;
+      case 'ExportDefaultDeclaration':
+        visit(current.declaration, current, 'declaration');
+        return;
+      case 'VariableDeclarator':
+        visitPatternDefaults(current.id);
+        visit(current.init, current, 'init');
+        return;
+      case 'FunctionDeclaration':
+        visitFunction(current);
+        return;
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+        visitFunction(current);
+        return;
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        visit(current.superClass, current, 'superClass');
+        visit(current.body, current, 'body');
+        return;
+      case 'MemberExpression':
+      case 'OptionalMemberExpression':
+        visit(current.object, current, 'object');
+        if (current.computed) {
+          visit(current.property, current, 'property');
+        }
+        return;
+      case 'Property':
+        if (current.computed) {
+          visit(current.key, current, 'key');
+        }
+        visit(current.value, current, 'value');
+        return;
+      case 'MethodDefinition':
+      case 'PropertyDefinition':
+        if (current.computed) {
+          visit(current.key, current, 'key');
+        }
+        if (!current.declare && !current.abstract) {
+          visit(current.value, current, 'value');
+        }
+        return;
+      case 'AssignmentPattern':
+        visit(current.right, current, 'right');
+        return;
+      case 'RestElement':
+        return;
+      case 'ObjectPattern':
+      case 'ArrayPattern':
+        visitPatternDefaults(current);
+        return;
+      case 'JSXElement':
+        visitJSXName(current.openingElement?.name);
+        for (const child of current.children || []) {
+          visit(child);
+        }
+        return;
+      case 'JSXFragment':
+        for (const child of current.children || []) {
+          visit(child);
+        }
+        return;
+      case 'JSXExpressionContainer':
+        visit(current.expression, current, 'expression');
+        return;
+    }
+
+    for (const [key, value] of Object.entries(current)) {
+      if (skipKeys.has(key)) continue;
+      visit(value, current, key);
+    }
+  };
+
+  visit(node);
+  return references;
+}
+
 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.isTypeScriptModule = options.isTypeScriptModule || false;
+    this.runtimeIdentifierReferences = null;
     this.abortSignal = options.abortSignal;
     this.executionController = options.executionController;
   }
@@ -163,6 +390,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);
@@ -209,15 +457,21 @@ export class Interpreter {
 
     // For Program nodes (evaluate all statements async)
     if (node.type === 'Program') {
+      const previousReferences = this.runtimeIdentifierReferences;
+      this.runtimeIdentifierReferences = collectRuntimeIdentifierReferences(node);
       let result = undefined;
-      for (const statement of node.body) {
-        result = await this.evaluateAsync(statement, env);
-        // Handle top-level return and throw
-        if (result instanceof ReturnValue || result instanceof ThrowSignal) {
-          return result;
+      try {
+        for (const statement of node.body) {
+          result = await this.evaluateAsync(statement, env);
+          // Handle top-level return and throw
+          if (result instanceof ReturnValue || result instanceof ThrowSignal) {
+            return result;
+          }
         }
+        return result;
+      } finally {
+        this.runtimeIdentifierReferences = previousReferences;
       }
-      return result;
     }
 
     // For import declarations (always async)
@@ -814,6 +1068,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);
@@ -974,6 +1249,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);
@@ -996,27 +1274,33 @@ export class Interpreter {
   }
 
   evaluateProgram(node, env) {
+    const previousReferences = this.runtimeIdentifierReferences;
+    this.runtimeIdentifierReferences = collectRuntimeIdentifierReferences(node);
     let result = undefined;
-    for (let i = 0; i < node.body.length; i++) {
-      const statement = node.body[i];
-      const isLast = i === node.body.length - 1;
-
-      // Special case: Last statement is a BlockStatement that looks like object literal
-      // Handle both shorthand { x, y } and full syntax { key: value, key2: value2 }
-      if (isLast && statement.type === 'BlockStatement') {
-        const objLiteral = this.tryConvertBlockToObjectLiteral(statement, env);
-        if (objLiteral !== null) {
-          return objLiteral;
+    try {
+      for (let i = 0; i < node.body.length; i++) {
+        const statement = node.body[i];
+        const isLast = i === node.body.length - 1;
+
+        // Special case: Last statement is a BlockStatement that looks like object literal
+        // Handle both shorthand { x, y } and full syntax { key: value, key2: value2 }
+        if (isLast && statement.type === 'BlockStatement') {
+          const objLiteral = this.tryConvertBlockToObjectLiteral(statement, env);
+          if (objLiteral !== null) {
+            return objLiteral;
+          }
         }
-      }
 
-      const statementResult = this.evaluate(statement, env);
-      if (statementResult instanceof ReturnValue || statementResult instanceof ThrowSignal) {
-        return statementResult;
+        const statementResult = this.evaluate(statement, env);
+        if (statementResult instanceof ReturnValue || statementResult instanceof ThrowSignal) {
+          return statementResult;
+        }
+        result = statementResult;
       }
-      result = statementResult;
+      return result;
+    } finally {
+      this.runtimeIdentifierReferences = previousReferences;
     }
-    return result;
   }
 
   // Try to convert a BlockStatement to an object literal
@@ -1396,7 +1680,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)
@@ -1719,6 +2005,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');
@@ -1823,42 +2137,72 @@ 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;
+    }
+
+    if (this.isTypeScriptModule &&
+        node.specifiers.length > 0 &&
+        node.specifiers.every(specifier => !this.isRuntimeImportSpecifier(specifier))) {
+      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,
+          isTypeScriptModule: isTypeScriptPath(resolvedPath),
+          abortSignal: this.abortSignal,
+          executionController: this.executionController
         });
         moduleInterpreter.moduleCache = this.moduleCache;  // Share cache
 
@@ -1867,12 +2211,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 (!this.isRuntimeImportSpecifier(specifier)) {
+        continue;
+      }
+
       if (specifier.type === 'ImportSpecifier') {
         // Named import: import { foo, bar } from "module"
         const importedName = specifier.imported.name;
@@ -1902,7 +2255,28 @@ export class Interpreter {
     return undefined;
   }
 
+  isRuntimeImportSpecifier(specifier) {
+    if (specifier.importKind === 'type') {
+      return false;
+    }
+
+    if (!this.isTypeScriptModule) {
+      return true;
+    }
+
+    const localName = specifier.local?.name;
+    if (!localName || !this.runtimeIdentifierReferences) {
+      return true;
+    }
+
+    return this.runtimeIdentifierReferences.has(localName);
+  }
+
   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);
@@ -1922,6 +2296,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;
@@ -1930,6 +2307,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);
@@ -2406,7 +2787,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)
@@ -2429,6 +2813,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);