pulse-js-framework 1.4.10 → 1.5.1

package/compiler/transformer/export.js

@@ -0,0 +1,33 @@
+/**
+ * Transformer Export Module
+ * Handles component export generation
+ * @module pulse-js-framework/compiler/transformer/export
+ */
+
+/**
+ * Generate component export
+ * @param {Object} transformer - Transformer instance
+ * @returns {string} JavaScript code
+ */
+export function generateExport(transformer) {
+  const pageName = transformer.ast.page?.name || 'Component';
+  const routePath = transformer.ast.route?.path || null;
+
+  const lines = ['// Export'];
+  lines.push(`export const ${pageName} = {`);
+  lines.push('  render,');
+
+  if (routePath) {
+    lines.push(`  route: ${JSON.stringify(routePath)},`);
+  }
+
+  lines.push('  mount: (target) => {');
+  lines.push('    const el = render();');
+  lines.push('    return mount(target, el);');
+  lines.push('  }');
+  lines.push('};');
+  lines.push('');
+  lines.push(`export default ${pageName};`);
+
+  return lines.join('\n');
+}

package/compiler/transformer/expressions.js

@@ -0,0 +1,273 @@
+/**
+ * Transformer Expressions Module
+ * Handles AST expression transformation to JavaScript code
+ * @module pulse-js-framework/compiler/transformer/expressions
+ */
+
+import { NodeType } from '../parser.js';
+import {
+  NO_SPACE_AFTER,
+  NO_SPACE_BEFORE,
+  STATEMENT_KEYWORDS,
+  BUILTIN_FUNCTIONS,
+  STATEMENT_TOKEN_TYPES,
+  STATEMENT_END_TYPES
+} from './constants.js';
+
+/**
+ * Transform AST expression to JS code
+ * @param {Object} transformer - Transformer instance
+ * @param {Object} node - AST node to transform
+ * @returns {string} JavaScript code
+ */
+export function transformExpression(transformer, node) {
+  if (!node) return '';
+
+  switch (node.type) {
+    case NodeType.Identifier:
+      if (transformer.stateVars.has(node.name)) {
+        return `${node.name}.get()`;
+      }
+      // Props are accessed directly (already destructured)
+      return node.name;
+
+    case NodeType.Literal:
+      if (typeof node.value === 'string') {
+        return JSON.stringify(node.value);
+      }
+      return String(node.value);
+
+    case NodeType.TemplateLiteral:
+      // Transform state vars in template literal
+      return '`' + transformExpressionString(transformer, node.value) + '`';
+
+    case NodeType.MemberExpression: {
+      const obj = transformExpression(transformer, node.object);
+      // Use optional chaining when accessing properties on function call results
+      const isCallResult = node.object.type === NodeType.CallExpression;
+      const accessor = isCallResult ? '?.' : '.';
+      if (node.computed) {
+        const prop = transformExpression(transformer, node.property);
+        return isCallResult ? `${obj}?.[${prop}]` : `${obj}[${prop}]`;
+      }
+      return `${obj}${accessor}${node.property}`;
+    }
+
+    case NodeType.CallExpression: {
+      const callee = transformExpression(transformer, node.callee);
+      const args = node.arguments.map(a => transformExpression(transformer, a)).join(', ');
+      return `${callee}(${args})`;
+    }
+
+    case NodeType.BinaryExpression: {
+      const left = transformExpression(transformer, node.left);
+      const right = transformExpression(transformer, node.right);
+      return `(${left} ${node.operator} ${right})`;
+    }
+
+    case NodeType.UnaryExpression: {
+      const argument = transformExpression(transformer, node.argument);
+      return `${node.operator}${argument}`;
+    }
+
+    case NodeType.UpdateExpression: {
+      const argument = transformExpression(transformer, node.argument);
+      // For state variables, convert x++ to x.set(x.get() + 1)
+      if (node.argument.type === NodeType.Identifier &&
+          transformer.stateVars.has(node.argument.name)) {
+        const name = node.argument.name;
+        const delta = node.operator === '++' ? 1 : -1;
+        return `${name}.set(${name}.get() + ${delta})`;
+      }
+      return node.prefix
+        ? `${node.operator}${argument}`
+        : `${argument}${node.operator}`;
+    }
+
+    case NodeType.ConditionalExpression: {
+      const test = transformExpression(transformer, node.test);
+      const consequent = transformExpression(transformer, node.consequent);
+      const alternate = transformExpression(transformer, node.alternate);
+      return `(${test} ? ${consequent} : ${alternate})`;
+    }
+
+    case NodeType.ArrowFunction: {
+      const params = node.params.join(', ');
+      if (node.block) {
+        // Block body - transform tokens
+        const body = transformFunctionBody(transformer, node.body);
+        return `(${params}) => { ${body} }`;
+      } else {
+        // Expression body
+        const body = transformExpression(transformer, node.body);
+        return `(${params}) => ${body}`;
+      }
+    }
+
+    case NodeType.AssignmentExpression: {
+      const left = transformExpression(transformer, node.left);
+      const right = transformExpression(transformer, node.right);
+      // For state variables, convert to .set()
+      if (node.left.type === NodeType.Identifier &&
+          transformer.stateVars.has(node.left.name)) {
+        return `${node.left.name}.set(${right})`;
+      }
+      return `(${left} = ${right})`;
+    }
+
+    case NodeType.ArrayLiteral: {
+      const elements = node.elements.map(e => transformExpression(transformer, e)).join(', ');
+      return `[${elements}]`;
+    }
+
+    case NodeType.ObjectLiteral: {
+      const props = node.properties.map(p => {
+        if (p.type === NodeType.SpreadElement) {
+          return `...${transformExpression(transformer, p.argument)}`;
+        }
+        if (p.shorthand) {
+          // Check if it's a state var
+          if (transformer.stateVars.has(p.name)) {
+            return `${p.name}: ${p.name}.get()`;
+          }
+          return p.name;
+        }
+        return `${p.name}: ${transformExpression(transformer, p.value)}`;
+      }).join(', ');
+      return `{ ${props} }`;
+    }
+
+    case NodeType.SpreadElement:
+      return `...${transformExpression(transformer, node.argument)}`;
+
+    default:
+      return '/* unknown expression */';
+  }
+}
+
+/**
+ * Transform expression string (from interpolation)
+ * @param {Object} transformer - Transformer instance
+ * @param {string} exprStr - Expression string
+ * @returns {string} Transformed expression string
+ */
+export function transformExpressionString(transformer, exprStr) {
+  // Simple transformation: wrap state vars with .get()
+  let result = exprStr;
+  for (const stateVar of transformer.stateVars) {
+    result = result.replace(
+      new RegExp(`\\b${stateVar}\\b`, 'g'),
+      `${stateVar}.get()`
+    );
+  }
+  // Add optional chaining after function calls followed by property access
+  result = result.replace(/(\w+\([^)]*\))\.(\w)/g, '$1?.$2');
+  return result;
+}
+
+/**
+ * Transform function body tokens back to code
+ * @param {Object} transformer - Transformer instance
+ * @param {Array} tokens - Body tokens
+ * @returns {string} JavaScript code
+ */
+export function transformFunctionBody(transformer, tokens) {
+  const { stateVars, actionNames } = transformer;
+  let code = '';
+  let lastToken = null;
+  let lastNonSpaceToken = null;
+
+  const needsManualSemicolon = (token, nextToken, lastNonSpace) => {
+    if (!token || lastNonSpace?.value === 'new') return false;
+    if (STATEMENT_TOKEN_TYPES.has(token.type)) return true;
+    if (token.type !== 'IDENT') return false;
+    if (STATEMENT_KEYWORDS.has(token.value)) return true;
+    if (stateVars.has(token.value) && nextToken?.type === 'EQ') return true;
+    if (nextToken?.type === 'LPAREN' &&
+        (BUILTIN_FUNCTIONS.has(token.value) || actionNames.has(token.value))) return true;
+    if (nextToken?.type === 'DOT' && BUILTIN_FUNCTIONS.has(token.value)) return true;
+    return false;
+  };
+
+  const afterStatementEnd = (t) => t && STATEMENT_END_TYPES.has(t.type);
+
+  let afterIfCondition = false;
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const nextToken = tokens[i + 1];
+
+    // Detect if we just closed an if/for/while condition
+    if (token.type === 'RPAREN') {
+      let parenDepth = 1;
+      for (let j = i - 1; j >= 0 && parenDepth > 0; j--) {
+        if (tokens[j].type === 'RPAREN') parenDepth++;
+        else if (tokens[j].type === 'LPAREN') parenDepth--;
+        if (parenDepth === 0) {
+          if (j > 0 && (tokens[j - 1].type === 'IF' || tokens[j - 1].type === 'FOR' ||
+                       tokens[j - 1].type === 'EACH' || tokens[j - 1].value === 'while')) {
+            afterIfCondition = true;
+          }
+          break;
+        }
+      }
+    }
+
+    // Add semicolon before statement starters
+    if (needsManualSemicolon(token, nextToken, lastNonSpaceToken) &&
+        afterStatementEnd(lastNonSpaceToken)) {
+      if (!afterIfCondition && lastToken && lastToken.value !== ';' && lastToken.value !== '{') {
+        code += '; ';
+      }
+    }
+
+    // Reset afterIfCondition after processing the token following the condition
+    if (afterIfCondition && token.type !== 'RPAREN') {
+      afterIfCondition = false;
+    }
+
+    // Emit the token value
+    if (token.type === 'STRING') {
+      code += token.raw || JSON.stringify(token.value);
+    } else if (token.type === 'TEMPLATE') {
+      code += token.raw || ('`' + token.value + '`');
+    } else {
+      code += token.value;
+    }
+
+    // Decide whether to add space after this token
+    const noSpaceAfter = NO_SPACE_AFTER.has(token.type) || NO_SPACE_AFTER.has(token.value);
+    const noSpaceBefore = nextToken &&
+      (NO_SPACE_BEFORE.has(nextToken.type) || NO_SPACE_BEFORE.has(nextToken.value));
+    if (!noSpaceAfter && !noSpaceBefore && nextToken) code += ' ';
+
+    lastToken = token;
+    lastNonSpaceToken = token;
+  }
+
+  // Build patterns for state variable transformation
+  const stateVarPattern = [...stateVars].join('|');
+  const funcPattern = [...actionNames, ...BUILTIN_FUNCTIONS].join('|');
+  const keywordsPattern = [...STATEMENT_KEYWORDS].join('|');
+
+  // Transform state var assignments: stateVar = value -> stateVar.set(value)
+  for (const stateVar of stateVars) {
+    const boundaryPattern = `\\s+(?:${stateVarPattern})(?:\\s*=(?!=)|\\s*\\.set\\()|\\s+(?:${funcPattern})\\s*\\(|\\s+(?:${keywordsPattern})\\b|;|$`;
+    const assignPattern = new RegExp(`\\b${stateVar}\\s*=(?!=)\\s*(.+?)(?=${boundaryPattern})`, 'g');
+    code = code.replace(assignPattern, (_, value) => `${stateVar}.set(${value.trim()});`);
+  }
+
+  // Clean up any double semicolons
+  code = code.replace(/;+/g, ';');
+  code = code.replace(/; ;/g, ';');
+
+  // Replace state var reads
+  for (const stateVar of stateVars) {
+    code = code.replace(
+      new RegExp(`(?<!\\.\\s*)\\b${stateVar}\\b(?!\\s*=(?!=)|\\s*\\(|\\s*\\.(?:get|set))`, 'g'),
+      `${stateVar}.get()`
+    );
+  }
+
+  return code.trim();
+}

package/compiler/transformer/imports.js

@@ -0,0 +1,101 @@
+/**
+ * Transformer Imports Module
+ * Handles import generation for compiled Pulse components
+ * @module pulse-js-framework/compiler/transformer/imports
+ */
+
+/**
+ * Extract imported component names from AST imports
+ * @param {Object} transformer - Transformer instance
+ * @param {Array} imports - Array of import statements from AST
+ */
+export function extractImportedComponents(transformer, imports) {
+  for (const imp of imports) {
+    for (const spec of imp.specifiers) {
+      transformer.importedComponents.set(spec.local, {
+        source: imp.source,
+        type: spec.type,
+        imported: spec.imported
+      });
+    }
+  }
+}
+
+/**
+ * Generate import statements (runtime + user imports)
+ * @param {Object} transformer - Transformer instance
+ * @returns {string} Generated import statements
+ */
+export function generateImports(transformer) {
+  const lines = [];
+  const { ast, options } = transformer;
+
+  // Runtime imports
+  const runtimeImports = [
+    'pulse',
+    'computed',
+    'effect',
+    'batch',
+    'el',
+    'text',
+    'on',
+    'list',
+    'when',
+    'mount',
+    'model'
+  ];
+
+  lines.push(`import { ${runtimeImports.join(', ')} } from '${options.runtime}';`);
+
+  // Router imports (if router block exists)
+  if (ast.router) {
+    lines.push(`import { createRouter } from '${options.runtime}/router';`);
+  }
+
+  // Store imports (if store block exists)
+  if (ast.store) {
+    const storeImports = ['createStore', 'createActions', 'createGetters'];
+    lines.push(`import { ${storeImports.join(', ')} } from '${options.runtime}/store';`);
+  }
+
+  // User imports from .pulse files
+  if (ast.imports && ast.imports.length > 0) {
+    lines.push('');
+    lines.push('// Component imports');
+
+    for (const imp of ast.imports) {
+      // Handle default + named imports
+      const defaultSpec = imp.specifiers.find(s => s.type === 'default');
+      const namedSpecs = imp.specifiers.filter(s => s.type === 'named');
+      const namespaceSpec = imp.specifiers.find(s => s.type === 'namespace');
+
+      let importStr = 'import ';
+      if (defaultSpec) {
+        importStr += defaultSpec.local;
+        if (namedSpecs.length > 0) {
+          importStr += ', ';
+        }
+      }
+      if (namespaceSpec) {
+        importStr += `* as ${namespaceSpec.local}`;
+      }
+      if (namedSpecs.length > 0) {
+        const named = namedSpecs.map(s =>
+          s.local !== s.imported ? `${s.imported} as ${s.local}` : s.local
+        );
+        importStr += `{ ${named.join(', ')} }`;
+      }
+
+      // Convert .pulse extension to .js
+      let source = imp.source;
+      if (source.endsWith('.pulse')) {
+        source = source.replace('.pulse', '.js');
+      }
+
+      importStr += ` from '${source}';`;
+      lines.push(importStr);
+    }
+  }
+
+  return lines.join('\n');
+}