jslike 1.3.0 → 1.4.0

package/src/index.js

@@ -1,186 +0,0 @@
-// Use bundled Acorn parser for zero runtime dependencies
-import { parse as acornParse } from './parser.js';
-import { Interpreter } from './interpreter/interpreter.js';
-import { Environment, ReturnValue } from './runtime/environment.js';
-import { createGlobalEnvironment } from './runtime/builtins.js';
-
-// Helper to detect if code contains module syntax or top-level await
-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)) {
-    return true;
-  }
-
-  // Check for top-level await (simple heuristic: await at start of line or after statement)
-  // This isn't perfect but handles common cases, including await in template literals
-  // Also matches await after operators like || or && or = or inside parentheses
-  if (/^await\s+/m.test(code) || /[;\n{(|&=]\s*await\s+/.test(code)) {
-    return true;
-  }
-
-  return false;
-}
-
-
-export function parse(code, options = {}) {
-  // Determine sourceType: use 'module' ONLY if explicitly requested or if code has imports/exports
-  // Default to 'script' for better compatibility with labeled statements
-  let sourceType = options.sourceType || 'script';
-  if (!options.sourceType && containsModuleSyntax(code)) {
-    sourceType = 'module';
-  }
-
-  // Parse with Acorn
-  try {
-    return acornParse(code, {
-      ecmaVersion: 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
-    });
-  } catch (error) {
-    // Reformat error message for consistency
-    throw new SyntaxError(
-      `Parse error at line ${error.loc?.line || '?'}: ${error.message}`
-    );
-  }
-}
-
-// Helper to detect if AST contains import/export declarations
-function containsModuleDeclarations(node) {
-  if (!node || typeof node !== 'object') return false;
-
-  if (node.type === 'ImportDeclaration' ||
-      node.type === 'ExportNamedDeclaration' ||
-      node.type === 'ExportDefaultDeclaration' ||
-      node.type === 'ExportAllDeclaration') {
-    return true;
-  }
-
-  // Check Program body for module declarations
-  if (node.type === 'Program' && node.body) {
-    for (const statement of node.body) {
-      if (containsModuleDeclarations(statement)) return true;
-    }
-  }
-
-  return false;
-}
-
-// Helper to detect if AST contains top-level await expressions
-function containsTopLevelAwait(node) {
-  if (!node || typeof node !== 'object') return false;
-
-  if (node.type === 'AwaitExpression') return true;
-
-  // Don't recurse into function bodies (they handle their own await)
-  if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
-    return false;
-  }
-
-  // Check all properties
-  for (const key in node) {
-    if (key === 'loc' || key === 'range') continue;
-    const value = node[key];
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (containsTopLevelAwait(item)) return true;
-      }
-    } else if (typeof value === 'object') {
-      if (containsTopLevelAwait(value)) return true;
-    }
-  }
-
-  return false;
-}
-
-export async function execute(code, env = null, options = {}) {
-  // Parse the code
-  const ast = parse(code, options);
-
-  // Create global environment if not provided
-  if (!env) {
-    env = createGlobalEnvironment(new Environment());
-  }
-
-  // Create a child environment for user code to allow shadowing of built-ins
-  // This prevents conflicts when user code declares variables with same names as stdlib functions
-  const userEnv = env.extend();
-
-  // 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, userEnv);
-    return result instanceof ReturnValue ? result.value : result;
-  } else {
-    const result = interpreter.evaluate(ast, userEnv);
-    return result instanceof ReturnValue ? result.value : result;
-  }
-}
-
-export function createEnvironment() {
-  return createGlobalEnvironment(new Environment());
-}
-
-// Export utility functions for CLI tools
-export const isTopLevelAwait = containsModuleSyntax;
-
-export { Interpreter } from './interpreter/interpreter.js';
-export { Environment } from './runtime/environment.js';
-export { WangInterpreter, InMemoryModuleResolver } from './interpreter/index.js';
-
-/**
- * Abstract base class for module resolution
- * Extend this class to implement custom module loading strategies
- */
-export class ModuleResolver {
-  /**
-   * Resolve a module and return its code
-   * @param {string} modulePath - The module path to resolve
-   * @param {string} [fromPath] - The path of the importing module
-   * @returns {Promise<ModuleResolution>} The resolved module
-   */
-  async resolve(modulePath, fromPath) {
-    throw new Error('ModuleResolver.resolve() must be implemented by subclass');
-  }
-
-  /**
-   * Check if a module exists
-   * @param {string} modulePath - The module path to check
-   * @param {string} [fromPath] - The path of the importing module
-   * @returns {Promise<boolean>} Whether the module exists
-   */
-  async exists(modulePath, fromPath) {
-    throw new Error('ModuleResolver.exists() must be implemented by subclass');
-  }
-
-  /**
-   * List available modules
-   * @param {string} [prefix] - Optional prefix to filter modules
-   * @returns {Promise<string[]>} List of module paths
-   */
-  async list(prefix) {
-    throw new Error('ModuleResolver.list() must be implemented by subclass');
-  }
-}
-
-/**
- * @typedef {Object} ModuleResolution
- * @property {string} code - The module source code
- * @property {string} path - The resolved module path
- * @property {any} [metadata] - Optional metadata about the module
- */

package/src/interpreter/index.js

@@ -1,201 +0,0 @@
-/**
- * WangInterpreter compatibility adapter for JSLike
- * Maps Wang's interpreter API to JSLike's API
- */
-
-import { execute, createEnvironment } from '../index.js';
-
-export class WangInterpreter {
-  constructor(options = {}) {
-    this.options = options;
-    this.moduleResolver = options.moduleResolver;
-    this.functions = options.functions || {};
-    // Create a persistent environment for setVariable support
-    this.persistentEnv = null;
-  }
-
-  setVariable(name, value) {
-    // If persistent environment doesn't exist, create it
-    if (!this.persistentEnv) {
-      this.persistentEnv = createEnvironment();
-
-      // Add custom functions
-      for (const [funcName, func] of Object.entries(this.functions)) {
-        if (this.persistentEnv.has(funcName)) {
-          this.persistentEnv.set(funcName, func);
-        } else {
-          this.persistentEnv.define(funcName, func);
-        }
-      }
-    }
-
-    // Set the variable in persistent environment
-    if (this.persistentEnv.has(name)) {
-      this.persistentEnv.set(name, value);
-    } else {
-      this.persistentEnv.define(name, value);
-    }
-  }
-
-  // Alias for setVariable - specifically for binding functions
-  bindFunction(name, func) {
-    return this.setVariable(name, func);
-  }
-
-  // Expose global context for accessing variables after execution
-  get globalContext() {
-    return {
-      variables: this.persistentEnv?.vars || new Map()
-    };
-  }
-
-  createExecutionEnvironment() {
-    // Create fresh environment for each execution
-    const env = createEnvironment();
-
-    // Add custom functions to environment, overriding built-ins if needed
-    for (const [name, func] of Object.entries(this.functions)) {
-      // Use set() to override existing variables instead of define()
-      if (env.has(name)) {
-        env.set(name, func);
-      } else {
-        env.define(name, func);
-      }
-    }
-
-    return env;
-  }
-
-  async execute(code, initialEnv = undefined, userOptions = {}) {
-    // Use provided environment, persistent environment, or create fresh one
-    const env = initialEnv || this.persistentEnv || this.createExecutionEnvironment();
-
-    // Setup console capture if withMetadata option is enabled
-    const withMetadata = userOptions.withMetadata || false;
-    const capturedLogs = [];
-
-    if (withMetadata) {
-      // Override log/warn/error functions to capture calls
-      const createCapture = (type) => {
-        return (...args) => {
-          capturedLogs.push({
-            type,
-            args,
-            timestamp: Date.now()
-          });
-          // Still output to console
-          console[type](...args);
-          return undefined;
-        };
-      };
-
-      env.set('log', createCapture('log'));
-      env.set('warn', createCapture('warn'));
-      env.set('error', createCapture('error'));
-    }
-
-    // Check if code contains top-level return statements
-    // Need to detect `return` at start of line, but NOT inside function bodies
-    // Simple heuristic: check if braces are balanced before the return statement
-    const hasTopLevelReturn = this.hasTopLevelReturn(code);
-
-    // Prepare execution options
-    const options = {
-      moduleResolver: this.moduleResolver
-      // sourceType will be auto-detected from code
-    };
-
-    let result;
-    if (hasTopLevelReturn) {
-      // Wrap code in async IIFE to support top-level return statements
-      const wrappedCode = `(async function() { ${code} })()`;
-      try {
-        result = await execute(wrappedCode, env, options);
-      } catch (error) {
-        throw error;
-      }
-    } else {
-      // Execute directly - JSLike returns last evaluated expression
-      try {
-        result = await execute(code, env, options);
-      } catch (error) {
-        throw error;
-      }
-    }
-
-    // Return result with metadata if requested
-    if (withMetadata) {
-      return {
-        result,
-        metadata: {
-          logs: capturedLogs
-        }
-      };
-    }
-
-    return result;
-  }
-
-  hasTopLevelReturn(code) {
-    const lines = code.split('\n');
-    let braceDepth = 0;
-
-    for (const line of lines) {
-      // Check if this line has a return statement at the start (ignoring whitespace)
-      const trimmed = line.trim();
-      if (trimmed.startsWith('return ') || trimmed === 'return') {
-        // If we're at brace depth 0, it's a top-level return
-        if (braceDepth === 0) {
-          return true;
-        }
-      }
-
-      // Count braces on this line (after checking for return)
-      for (const char of line) {
-        if (char === '{') braceDepth++;
-        if (char === '}') braceDepth--;
-      }
-    }
-
-    return false;
-  }
-
-  async executeModule(code) {
-    // Same as execute for now - modules are handled by execute()
-    return await this.execute(code);
-  }
-}
-
-export class InMemoryModuleResolver {
-  constructor() {
-    this.modules = new Map();
-  }
-
-  addModule(name, code, metadata) {
-    this.modules.set(name, { code, metadata });
-  }
-
-  async resolve(modulePath, fromPath) {
-    const module = this.modules.get(modulePath);
-    if (!module) {
-      return null;
-    }
-    return {
-      code: typeof module === 'string' ? module : module.code,
-      path: modulePath,
-      metadata: module.metadata
-    };
-  }
-
-  async exists(modulePath, fromPath) {
-    return this.modules.has(modulePath);
-  }
-
-  async list(prefix) {
-    const paths = Array.from(this.modules.keys());
-    if (prefix) {
-      return paths.filter(p => p.startsWith(prefix));
-    }
-    return paths;
-  }
-}