jslike 1.8.0 → 1.8.2

package/README.md

@@ -7,6 +7,7 @@
 - **Production-Ready** - Handles files of any size, tested with 1000+ tests
 - **Full ES6+ JavaScript Support** - Classes, destructuring, template literals, spread operator, arrow functions
 - **Native JSX Support** - Parse and execute JSX without pre-transformation
+- **TypeScript & TSX Module Support** - Execute JS-compatible TypeScript syntax directly from `.ts`, `.tsx`, `.mts`, and `.cts` modules
 - **React Integration** - Import React hooks and components via moduleResolver
 - **CSP-Safe** - Tree-walking interpreter, no eval() or new Function()
 - **ASI (Automatic Semicolon Insertion)** - Write JavaScript naturally without mandatory semicolons
@@ -143,9 +144,10 @@ const moduleResolver = {
 
 ```javascript
 const moduleResolver = {
-  async resolve(modulePath) {
+  async resolve(modulePath, fromPath) {
     if (modulePath === './utils') {
       return {
+        path: '/virtual/project/utils.js',
         code: `
           export function double(x) { return x * 2; }
           export const PI = 3.14159;
@@ -157,6 +159,40 @@ const moduleResolver = {
 };
 ```
 
+`fromPath` is the path of the importing module. For top-level code, pass `sourcePath` to `execute()` so relative imports have a deterministic root. For nested imports, JSLike passes the resolved module `path` returned by the resolver.
+
+```javascript
+const files = {
+  '/virtual/project/main.ts': `
+    import { user } from './user.ts';
+    user.name
+  `,
+  '/virtual/project/user.ts': `
+    type User = { name: string };
+    export const user: User = { name: 'Ada' };
+  `
+};
+
+const moduleResolver = {
+  async resolve(modulePath, fromPath) {
+    const base = new URL('.', `file://${fromPath}`).pathname;
+    const resolvedPath = new URL(modulePath, `file://${base}`).pathname;
+
+    if (!files[resolvedPath]) return null;
+    return {
+      path: resolvedPath,
+      code: files[resolvedPath]
+    };
+  }
+};
+
+const result = await execute(files['/virtual/project/main.ts'], null, {
+  moduleResolver,
+  sourcePath: '/virtual/project/main.ts'
+});
+// "Ada"
+```
+
 ### Import Styles Supported
 
 ```javascript
@@ -165,6 +201,44 @@ import React from 'react';                        // Default import
 import * as Utils from './utils';                 // Namespace import
 ```
 
+## TypeScript Support
+
+JSLike parses TypeScript and TSX with a bundled `@sveltejs/acorn-typescript` parser. TypeScript syntax is enabled automatically for `sourcePath` and resolved module paths ending in `.ts`, `.tsx`, `.mts`, or `.cts`. You can also force it with `typescript: true` or `tsx: true`.
+
+```javascript
+const result = await execute(`
+  interface User {
+    name: string;
+  }
+
+  enum Role {
+    Admin,
+    Member
+  }
+
+  class Account {
+    constructor(public user: User, readonly role: Role) {}
+  }
+
+  const account = new Account({ name: 'Ada' }, Role.Admin);
+  account.user.name + ':' + account.role
+`, null, {
+  sourcePath: '/virtual/account.ts'
+});
+// "Ada:0"
+```
+
+Supported TypeScript runtime behavior:
+
+- Type-only declarations and annotations are erased: `type`, `interface`, `declare`, parameter/return annotations, tuple/readonly annotations.
+- Type-only imports and exports do not trigger runtime module resolution.
+- Type wrappers evaluate their inner expression: `as`, `<T>value`, `satisfies`, non-null `!`, generic call instantiation.
+- Enums execute as runtime enum objects, including numeric reverse mappings and string enum members.
+- Constructor parameter properties assign to `this`, including `public`, `private`, and `readonly`.
+- TSX parses and executes JSX in `.tsx` files or with `tsx: true`.
+
+Unsupported runtime TypeScript constructs throw explicit errors instead of executing incorrectly. This currently includes `namespace`, `export =`, and `import x = require(...)`.
+
 ## JSX Features
 
 ### Basic Elements

package/dist/esm/errors/enhanced-error.js

@@ -54,22 +54,48 @@ function getAvailableMethods(obj) {
 
   const methods = new Set();
 
-  // Get own properties
-  Object.getOwnPropertyNames(obj).forEach(name => {
-    if (typeof obj[name] === 'function') {
-      methods.add(name);
+  const addSafeMethods = (target, includeConstructor = true) => {
+    let names;
+    try {
+      names = Object.getOwnPropertyNames(target);
+    } catch {
+      return;
     }
-  });
 
-  // Get prototype methods
-  let proto = Object.getPrototypeOf(obj);
-  while (proto && proto !== Object.prototype) {
-    Object.getOwnPropertyNames(proto).forEach(name => {
-      if (typeof proto[name] === 'function' && name !== 'constructor') {
+    names.forEach(name => {
+      if (!includeConstructor && name === 'constructor') return;
+
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(target, name);
+      } catch {
+        return;
+      }
+
+      if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
         methods.add(name);
       }
     });
-    proto = Object.getPrototypeOf(proto);
+  };
+
+  // Get own properties
+  addSafeMethods(obj);
+
+  // Get prototype methods
+  let proto;
+  try {
+    proto = Object.getPrototypeOf(obj);
+  } catch {
+    proto = null;
+  }
+
+  while (proto && proto !== Object.prototype) {
+    addSafeMethods(proto, false);
+    try {
+      proto = Object.getPrototypeOf(proto);
+    } catch {
+      proto = null;
+    }
   }
 
   return Array.from(methods).sort();

package/dist/esm/index.js

@@ -130,7 +130,8 @@ export async function execute(code, env = null, options = {}) {
       moduleResolver: options.moduleResolver,
       abortSignal: options.abortSignal,
       executionController: controller,
-      currentModulePath: options.sourcePath
+      currentModulePath: options.sourcePath,
+      isTypeScriptModule: options.typescript || options.tsx || isTypeScriptPath(options.sourcePath)
     });
 
     // Use async evaluation if:

package/dist/esm/interpreter/interpreter.js

@@ -57,6 +57,174 @@ function getPatternName(pattern) {
   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;
@@ -65,6 +233,8 @@ export class Interpreter {
     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;
   }
@@ -287,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)
@@ -1098,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
@@ -1960,6 +2142,12 @@ export class Interpreter {
       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');
@@ -2012,6 +2200,7 @@ export class Interpreter {
           moduleResolver: this.moduleResolver,
           moduleResolutionCache: this.moduleResolutionCache,
           currentModulePath: resolvedPath,
+          isTypeScriptModule: isTypeScriptPath(resolvedPath),
           abortSignal: this.abortSignal,
           executionController: this.executionController
         });
@@ -2033,7 +2222,7 @@ export class Interpreter {
   bindImportSpecifiers(node, env, modulePath, moduleExports) {
     // Import specified bindings into current environment
     for (const specifier of node.specifiers) {
-      if (specifier.importKind === 'type') {
+      if (!this.isRuntimeImportSpecifier(specifier)) {
         continue;
       }
 
@@ -2066,6 +2255,23 @@ 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;