coffeehaml 0.7.0 → 0.7.1

package/dist/src/cli.js

@@ -0,0 +1,430 @@
+// Generated by CoffeeScript 2.7.0
+  //!/usr/bin/env node
+  // cli.coffee — CoffeeHaml command-line interface
+var _require, args, ask, cmd, compileFn, doCompile, doInit, file, files, findFiles, formatError, formatWarning, getVersion, i, initial, len, ok, opts, parseArgs, parseWrapFlag, rest, stats, target, timers, watchDir, watcher,
+  indexOf = [].indexOf;
+
+import {
+  compileFile
+} from './index.js';
+
+import {
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  watch,
+  statSync,
+  readdirSync,
+  mkdirSync
+} from 'fs';
+
+import {
+  fileURLToPath
+} from 'url';
+
+import {
+  dirname,
+  join,
+  resolve,
+  relative
+} from 'path';
+
+import {
+  createInterface
+} from 'readline';
+
+import {
+  createRequire
+} from 'module';
+
+_require = createRequire(import.meta.url);
+
+getVersion = function() {
+  var __dirname, pkg;
+  try {
+    __dirname = dirname(fileURLToPath(import.meta.url));
+    pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch (error) {
+    return '0.0.0';
+  }
+};
+
+args = process.argv.slice(2);
+
+if (args.length === 0 || indexOf.call(args, '--help') >= 0 || indexOf.call(args, '-h') >= 0) {
+  console.log(`CoffeeHaml v${getVersion()}
+  Haml structure. CoffeeScript semantics. React runtime.
+
+Usage:
+  coffeehaml init                                        scaffold a new project
+  coffeehaml compile <input> [-o <output>] [--source-map] [--wrap <mode>]
+  coffeehaml watch <input> [-o <output>] [--source-map] [--wrap <mode>]
+
+Options:
+  -o, --output <file>   Write output to file instead of stdout
+  --source-map          Emit inline source map
+  --wrap <mode>         Wrap output: 'component', 'observer', or comma-separated HOC list
+  -h, --help            Show this help
+
+Examples:
+  coffeehaml init
+  coffeehaml compile app.chaml -o app.js --wrap component
+  coffeehaml compile app.chaml                           # prints to stdout
+  coffeehaml watch src/ --wrap observer                  # watch and recompile on change`);
+  process.exit(0);
+}
+
+parseWrapFlag = function(args) {
+  var idx, val;
+  idx = args.indexOf('--wrap');
+  if (idx === -1) {
+    return void 0;
+  }
+  val = args[idx + 1];
+  if (!(val && !val.startsWith('-'))) {
+    return void 0;
+  }
+  if (val === 'component' || val === 'observer' || val === 'none') {
+    return val;
+  }
+  return val.split(',').map(function(s) {
+    return s.trim();
+  }).filter(Boolean);
+};
+
+parseArgs = function(args) {
+  var outIdx, output, sourceMap, wrap;
+  outIdx = args.indexOf('-o') !== -1 ? args.indexOf('-o') : args.indexOf('--output');
+  output = outIdx !== -1 ? args[outIdx + 1] : void 0;
+  sourceMap = indexOf.call(args, '--source-map') >= 0;
+  wrap = parseWrapFlag(args);
+  return {
+    input: args[0],
+    output,
+    sourceMap,
+    wrap
+  };
+};
+
+formatError = function(err, filename) {
+  var loc, msg;
+  loc = err.location;
+  msg = loc ? `${filename}:${loc.start.line + 1}:${loc.start.column + 1}: [${err.code}] ${err.message}` : `[${err.code}] ${err.message}`;
+  if (err.hint) {
+    msg += `\n  Hint: ${err.hint}`;
+  }
+  return msg;
+};
+
+formatWarning = function(warn, filename) {
+  var loc;
+  loc = warn.location;
+  if (loc) {
+    return `Warning: ${filename}:${loc.start.line + 1}:${loc.start.column + 1}: ${warn.message}`;
+  } else {
+    return `Warning: ${warn.message}`;
+  }
+};
+
+doCompile = function(input, opts) {
+  var err, i, j, len, len1, ref, ref1, result, warn;
+  result = compileFile(input, {
+    filename: input,
+    sourceMap: opts.sourceMap,
+    wrap: opts.wrap
+  });
+  if (result.errors.length > 0) {
+    ref = result.errors;
+    for (i = 0, len = ref.length; i < len; i++) {
+      err = ref[i];
+      console.error(formatError(err, input));
+    }
+    return false;
+  }
+  ref1 = result.warnings;
+  for (j = 0, len1 = ref1.length; j < len1; j++) {
+    warn = ref1[j];
+    console.error(formatWarning(warn, input));
+  }
+  if (opts.output) {
+    writeFileSync(opts.output, result.code);
+    if (result.sourceMap) {
+      writeFileSync(opts.output + '.map', result.sourceMap);
+    }
+    console.error(`Compiled: ${input} → ${opts.output}`);
+  } else {
+    process.stdout.write(result.code);
+  }
+  return true;
+};
+
+// ─── Init ──────────────────────────────────────────────────
+ask = function(q) {
+  var rl;
+  rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(function(resolve) {
+    return rl.question(q, function(answer) {
+      rl.close();
+      return resolve(answer.trim());
+    });
+  });
+};
+
+doInit = async function() {
+  var addDep, addScripts, ans, configPath, content, createSample, cwd, detections, execSync, existing, ext, hasImport, hasPkg, hasPlugin, hasTsConfig, hasViteConfig, pkg, pkgPath, sample, samplePath, setupVite, srcDir;
+  cwd = process.cwd();
+  hasPkg = existsSync(join(cwd, 'package.json'));
+  hasViteConfig = existsSync(join(cwd, 'vite.config.ts')) || existsSync(join(cwd, 'vite.config.js'));
+  hasTsConfig = existsSync(join(cwd, 'tsconfig.json'));
+  console.log("\n  ☕ CoffeeHaml init — project scaffold\n");
+  console.log(`  Working directory: ${cwd}`);
+  detections = [];
+  if (hasPkg) {
+    detections.push('package.json');
+  }
+  if (hasViteConfig) {
+    detections.push('Vite');
+  }
+  if (hasTsConfig) {
+    detections.push('TypeScript');
+  }
+  if (!hasPkg) {
+    detections.push('bare project');
+  }
+  console.log(`  Detected: ${detections.join(', ')}\n`);
+  addDep = true;
+  if (hasPkg) {
+    ans = (await ask('  Add coffeehaml as devDependency? (Y/n): '));
+    addDep = !/^n/i.test(ans);
+  } else {
+    console.log('  No package.json found — skipping dependency install.');
+    addDep = false;
+  }
+  setupVite = false;
+  if (hasViteConfig) {
+    ans = (await ask('  Configure Vite plugin? (Y/n): '));
+    setupVite = !/^n/i.test(ans);
+  } else if (hasPkg) {
+    ans = (await ask('  No vite.config detected. Create one with CoffeeHaml plugin? (y/N): '));
+    setupVite = /^y/i.test(ans);
+  }
+  createSample = true;
+  ans = (await ask('  Create sample .chaml component? (Y/n): '));
+  createSample = !/^n/i.test(ans);
+  addScripts = false;
+  if (hasPkg) {
+    ans = (await ask('  Add build/watch scripts to package.json? (Y/n): '));
+    addScripts = !/^n/i.test(ans);
+  }
+  console.log('');
+  // Execute
+  if (addDep) {
+    console.log('  ⚡ Installing coffeehaml...');
+    ({execSync} = _require('child_process'));
+    try {
+      execSync('npm install --save-dev coffeehaml', {
+        cwd: cwd,
+        stdio: 'inherit'
+      });
+      console.log('  ✓ coffeehaml installed\n');
+    } catch (error) {
+      console.log('  ✗ Install failed — continuing anyway\n');
+    }
+  }
+  if (setupVite) {
+    configPath = hasViteConfig ? existsSync(join(cwd, 'vite.config.ts')) ? join(cwd, 'vite.config.ts') : join(cwd, 'vite.config.js') : join(cwd, 'vite.config.ts');
+    ext = configPath.endsWith('.ts') ? 'ts' : 'js';
+    if (hasViteConfig) {
+      existing = readFileSync(configPath, 'utf-8');
+      hasImport = /coffeehaml/.test(existing);
+      hasPlugin = /coffeehaml\(\)/.test(existing);
+      if (!hasImport) {
+        existing = "import coffeehaml from 'coffeehaml/vite-plugin';\n" + existing;
+      }
+      if (!hasPlugin) {
+        existing = existing.replace(/(plugins\s*:\s*\[)/, '$1\n    coffeehaml(),');
+        if (!/plugins\s*:\s*\[/.test(existing)) {
+          existing = existing.replace(/(defineConfig\s*\(\s*\{)/, '$1\n  plugins: [coffeehaml()],');
+        }
+      }
+      writeFileSync(configPath, existing);
+      console.log(`  ✓ Updated ${relative(cwd, configPath)}\n`);
+    } else {
+      content = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import coffeehaml from 'coffeehaml/vite-plugin';
+
+export default defineConfig({
+  plugins: [
+    react(),
+    coffeehaml(),
+  ],
+});`;
+      writeFileSync(configPath, content);
+      console.log(`  ✓ Created ${relative(cwd, configPath)}\n`);
+    }
+  }
+  if (createSample) {
+    srcDir = join(cwd, 'src');
+    if (!existsSync(srcDir)) {
+      mkdirSync(srcDir, {
+        recursive: true
+      });
+    }
+    samplePath = join(srcDir, 'App.chaml');
+    if (existsSync(samplePath)) {
+      console.log(`  ⚠ ${relative(cwd, samplePath)} already exists — skipping\n`);
+    } else {
+      sample = `-# App.chaml — a sample CoffeeHaml component
+import { useState } from 'react'
+
+%div.app
+  %header
+    %h1= "CoffeeHaml ✨"
+    %p.subtitle Haml structure. CoffeeScript semantics. React runtime.
+
+  %main
+    - name = 'World'
+    %section.card
+      %h2= "Hello, \#{name}!"
+      %p= "Counter: 0"
+
+    %footer
+      %small Built with coffeehaml v${getVersion()}`;
+      writeFileSync(samplePath, sample);
+      console.log(`  ✓ Created ${relative(cwd, samplePath)}\n`);
+    }
+  }
+  if (addScripts && hasPkg) {
+    pkgPath = join(cwd, 'package.json');
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    pkg.scripts = pkg.scripts || {};
+    if (!pkg.scripts['build:chaml']) {
+      pkg.scripts['build:chaml'] = 'coffeehaml compile src/ -o dist/';
+    }
+    if (!pkg.scripts['watch:chaml']) {
+      pkg.scripts['watch:chaml'] = 'coffeehaml watch src/ --wrap component';
+    }
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    console.log('  ✓ Added build:chaml and watch:chaml scripts\n');
+  }
+  console.log('  🎉 Done! Start building:\n');
+  console.log('    npm run build:chaml       # compile once');
+  console.log('    npm run watch:chaml       # watch and recompile');
+  return console.log('    npx coffeehaml watch src/ # ad-hoc watch\n');
+};
+
+// ─── Main ──────────────────────────────────────────────────
+cmd = args[0];
+
+rest = args.slice(1);
+
+switch (cmd) {
+  case 'compile':
+    opts = parseArgs(rest);
+    if (!opts.input) {
+      console.error('Error: no input file specified');
+      process.exit(1);
+    }
+    ok = doCompile(opts.input, opts);
+    process.exit(ok ? 0 : 1);
+    break;
+  case 'watch':
+    opts = parseArgs(rest);
+    if (!opts.input) {
+      console.error('Error: no input path specified');
+      process.exit(1);
+    }
+    target = resolve(opts.input);
+    stats = existsSync(target) ? statSync(target) : null;
+    files = [];
+    findFiles = function(dir) {
+      var entry, full, i, len, ref, results, stat;
+      if (!existsSync(dir)) {
+        return;
+      }
+      stat = statSync(dir);
+      if (stat.isDirectory()) {
+        ref = readdirSync(dir, {
+          withFileTypes: true
+        });
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          entry = ref[i];
+          full = join(dir, entry.name);
+          if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+            results.push(findFiles(full));
+          } else if (entry.isFile() && /\.(chaml|coffeehaml)$/.test(entry.name)) {
+            results.push(files.push(full));
+          } else {
+            results.push(void 0);
+          }
+        }
+        return results;
+      } else if (/\.(chaml|coffeehaml)$/.test(dir)) {
+        return files.push(dir);
+      }
+    };
+    findFiles(target);
+    if (files.length === 0) {
+      console.error(`Error: no .chaml/.coffeehaml files found in ${opts.input}`);
+      process.exit(1);
+    }
+    console.error(`Watching ${files.length} file(s)...`);
+    initial = true;
+    compileFn = function(file) {
+      var outFile, rel;
+      rel = relative(process.cwd(), file);
+      if (!initial) {
+        console.error(`\n[recompile] ${rel}`);
+      }
+      initial = false;
+      outFile = opts.output || file.replace(/\.(chaml|coffeehaml)$/, '.js');
+      ok = doCompile(file, {
+        ...opts,
+        output: outFile,
+        input: file
+      });
+      if (!ok) {
+        return console.error(`  ✗ ${rel}`);
+      }
+    };
+    for (i = 0, len = files.length; i < len; i++) {
+      file = files[i];
+      compileFn(file);
+    }
+    timers = new Map();
+    watchDir = (stats != null ? stats.isDirectory() : void 0) ? target : dirname(target);
+    watcher = watch(watchDir, {
+      recursive: true
+    }, function(_event, filename) {
+      var full;
+      if (!(filename && /\.(chaml|coffeehaml)$/.test(filename))) {
+        return;
+      }
+      full = resolve(watchDir, filename);
+      if (timers.has(full)) {
+        clearTimeout(timers.get(full));
+      }
+      return timers.set(full, setTimeout((function() {
+        timers.delete(full);
+        return compileFn(full);
+      }), 100));
+    });
+    process.on('SIGINT', function() {
+      watcher.close();
+      console.error('\nStopped watching.');
+      return process.exit(0);
+    });
+    break;
+  case 'init':
+    doInit();
+    break;
+  default:
+    console.error(`Unknown command: ${cmd}`);
+    process.exit(1);
+}

package/dist/src/compiler.js

@@ -0,0 +1,132 @@
+// Generated by CoffeeScript 2.7.0
+// compiler.coffee — compile pipeline orchestration
+var wrapError;
+
+import {
+  tokenize
+} from './lexer.js';
+
+import {
+  parse
+} from './parser.js';
+
+import {
+  emit
+} from './emitter.js';
+
+import {
+  CompileError
+} from './types.js';
+
+import {
+  isCoffeeScriptAvailable,
+  getCoffeeScriptUnavailableReason
+} from './expressions.js';
+
+import {
+  readFileSync,
+  existsSync
+} from 'fs';
+
+// Supported extensions
+export var COFFEEHAML_EXTENSIONS = ['.coffeehaml', '.cohaml', '.chaml'];
+
+// Resolve a CoffeeHaml file path
+export var resolveCoffeeHamlFile = function(filepath) {
+  var ext, i, len, withExt;
+  if (existsSync(filepath)) {
+    return filepath;
+  }
+  for (i = 0, len = COFFEEHAML_EXTENSIONS.length; i < len; i++) {
+    ext = COFFEEHAML_EXTENSIONS[i];
+    withExt = filepath + ext;
+    if (existsSync(withExt)) {
+      return withExt;
+    }
+  }
+  return null;
+};
+
+// Compile CoffeeHaml source to JavaScript
+export var compile = function(source, options = {}) {
+  var ast, e, errors, parsed, result, tokens, warnings;
+  errors = [];
+  warnings = [];
+  // Warn if CoffeeScript unavailable
+  if (!isCoffeeScriptAvailable()) {
+    warnings.push({
+      message: `CoffeeScript expression compiler unavailable: ${getCoffeeScriptUnavailableReason()}. CoffeeScript expressions will passthrough raw and may produce invalid JavaScript. Install coffeescript as a peer dependency.`,
+      phase: 'compiler'
+    });
+  }
+  try {
+    // Phase 1: Lex
+    tokens = tokenize(source, options.filename);
+  } catch (error) {
+    e = error;
+    return {
+      code: '',
+      errors: [wrapError(e, 'lexer')],
+      warnings: []
+    };
+  }
+  // Phase 2: Parse
+  parsed = parse(tokens, options.filename);
+  ast = parsed.document;
+  if (parsed.errors.length > 0) {
+    errors.push(...parsed.errors);
+    if (ast.children.length === 0) {
+      return {
+        code: '',
+        errors,
+        warnings
+      };
+    }
+  }
+  try {
+    // Phase 3: Emit
+    result = emit(ast, {
+      sourceMap: options.sourceMap,
+      filename: options.filename,
+      jsxRuntime: options.jsxRuntime,
+      filters: options.filters,
+      wrap: options.wrap,
+      componentName: options.componentName
+    });
+  } catch (error) {
+    e = error;
+    return {
+      code: '',
+      errors: [wrapError(e, 'emitter')],
+      warnings
+    };
+  }
+  if (result.warnings) {
+    warnings.push(...result.warnings);
+  }
+  return {
+    code: result.code,
+    sourceMap: result.sourceMap,
+    errors,
+    warnings
+  };
+};
+
+// Compile from disk
+export var compileFile = function(filepath, options = {}) {
+  var source;
+  source = readFileSync(filepath, 'utf-8');
+  return compile(source, {
+    ...options,
+    filename: filepath
+  });
+};
+
+// ─── Helpers ───────────────────────────────────────────────
+wrapError = function(e, phase) {
+  if (e instanceof CompileError) {
+    e.phase = phase;
+    return e;
+  }
+  return new CompileError(e instanceof Error ? e.message : String(e), phase, 'INTERNAL_ERROR');
+};