jslike 1.7.3 → 1.8.1

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
@@ -473,7 +547,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,9 @@ 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,
+      isTypeScriptModule: options.typescript || options.tsx || isTypeScriptPath(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
     };