@xnoxs/flux-lang 3.2.1 → 3.3.0

package/src/sourcemap.js

@@ -1,82 +0,0 @@
-'use strict';
-
-/**
- * Source Map v3 Generator
- * Maps generated JS line/col back to original Flux source line/col.
- */
-
-const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-function encodeVLQ(value) {
-  let vlq = value < 0 ? ((-value) << 1) | 1 : (value << 1);
-  let result = '';
-  do {
-    let digit = vlq & 0x1F;
-    vlq >>>= 5;
-    if (vlq > 0) digit |= 0x20;
-    result += BASE64[digit];
-  } while (vlq > 0);
-  return result;
-}
-
-class SourceMapBuilder {
-  constructor(sourceFile, sourceContent) {
-    this.sourceFile    = sourceFile;
-    this.sourceContent = sourceContent;
-    // mappings[genLine] = [{ genCol, srcLine, srcCol }, ...]
-    // All indices are 0-based.
-    this.mappings = [];
-  }
-
-  /**
-   * Record one mapping.
-   * @param {number} genLine  - 0-based generated (JS) line
-   * @param {number} genCol   - 0-based generated column
-   * @param {number} srcLine  - 0-based source (.flux) line
-   * @param {number} srcCol   - 0-based source column
-   */
-  addMapping(genLine, genCol, srcLine, srcCol) {
-    while (this.mappings.length <= genLine) this.mappings.push([]);
-    this.mappings[genLine].push({ genCol, srcLine, srcCol });
-  }
-
-  // VLQ-encode all mappings into source map v3 "mappings" string
-  encodeMappings() {
-    let prevSrcLine = 0;
-    let prevSrcCol  = 0;
-
-    return this.mappings.map(lineSegs => {
-      let prevGenCol = 0;
-      return lineSegs.map(seg => {
-        const encoded = [
-          encodeVLQ(seg.genCol  - prevGenCol),
-          encodeVLQ(0),                           // source file index (always 0)
-          encodeVLQ(seg.srcLine - prevSrcLine),
-          encodeVLQ(seg.srcCol  - prevSrcCol),
-        ].join('');
-        prevGenCol  = seg.genCol;
-        prevSrcLine = seg.srcLine;
-        prevSrcCol  = seg.srcCol;
-        return encoded;
-      }).join(',');
-    }).join(';');
-  }
-
-  toJSON(outputFile = '') {
-    return {
-      version:        3,
-      file:           outputFile,
-      sourceRoot:     '',
-      sources:        [this.sourceFile],
-      sourcesContent: [this.sourceContent],
-      names:          [],
-      mappings:       this.encodeMappings(),
-    };
-  }
-
-  toString(outputFile = '') {
-    return JSON.stringify(this.toJSON(outputFile));
-  }
-}
-
-module.exports = { SourceMapBuilder, encodeVLQ };

package/src/test-runner.js

@@ -1,239 +0,0 @@
-'use strict';
-
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
-
-// ── Test Runner ───────────────────────────────────────────────────────────────
-// Discovers and runs Flux test files (*.test.flux)
-// Test functions must be named test_* (e.g. fn test_arithmetic():)
-// Globals injected: assert(cond, msg), assertEqual(a, b), assertThrows(fn, msg)
-
-const C = {
-  reset:  '\x1b[0m',
-  bold:   '\x1b[1m',
-  red:    '\x1b[31m',
-  green:  '\x1b[32m',
-  yellow: '\x1b[33m',
-  cyan:   '\x1b[36m',
-  gray:   '\x1b[90m',
-  dim:    '\x1b[2m',
-};
-const clr = (c, s) => (process.env.NO_COLOR ? s : `${c}${s}${C.reset}`);
-
-// ── Assertion helpers injected into test execution ────────────────────────────
-const TEST_HELPERS = `
-"use strict";
-
-const __results = [];
-let   __current = null;
-
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || 'Assertion failed: expected truthy');
-  }
-}
-
-function assertEqual(actual, expected, message) {
-  const ok = JSON.stringify(actual) === JSON.stringify(expected);
-  if (!ok) {
-    throw new Error(
-      message ||
-      'Expected ' + JSON.stringify(expected) + ' but got ' + JSON.stringify(actual)
-    );
-  }
-}
-
-function assertNotEqual(actual, expected, message) {
-  const ok = JSON.stringify(actual) !== JSON.stringify(expected);
-  if (!ok) {
-    throw new Error(message || 'Expected values to be different but both were ' + JSON.stringify(actual));
-  }
-}
-
-function assertThrows(fn, message) {
-  try { fn(); }
-  catch (_) { return; }
-  throw new Error(message || 'Expected function to throw, but it did not');
-}
-
-function assertClose(actual, expected, delta, message) {
-  delta = delta || 1e-9;
-  if (Math.abs(actual - expected) > delta) {
-    throw new Error(message || ('Expected ' + actual + ' to be close to ' + expected + ' (delta=' + delta + ')'));
-  }
-}
-
-// Register test results
-function __runTest(name, fn) {
-  try {
-    fn();
-    __results.push({ name: name, ok: true });
-  } catch(e) {
-    __results.push({ name: name, ok: false, error: e.message });
-  }
-}
-
-// Auto-detect and run test functions after module evaluation
-function __runAll(mod) {
-  const names = Object.getOwnPropertyNames(mod).filter(k => k.startsWith('test_') && typeof mod[k] === 'function');
-  for (const n of names) __runTest(n.replace(/^test_/, '').replace(/_/g, ' '), mod[n]);
-  return __results;
-}
-`;
-
-function discoverTestFiles(target) {
-  const abs = path.resolve(target);
-
-  if (!fs.existsSync(abs)) {
-    throw new Error(`Not found: ${abs}`);
-  }
-
-  const stat = fs.statSync(abs);
-  if (stat.isDirectory()) {
-    return fs.readdirSync(abs)
-      .filter(f => f.endsWith('.test.flux'))
-      .map(f => path.join(abs, f))
-      .sort();
-  }
-
-  if (abs.endsWith('.flux')) return [abs];
-  throw new Error(`Expected a .flux file or directory, got: ${abs}`);
-}
-
-function runTestFile(filePath, transpile) {
-  const source = fs.readFileSync(filePath, 'utf8');
-  const result = transpile(source);
-
-  if (!result.success) {
-    return {
-      file:    path.basename(filePath),
-      errors:  result.errors,
-      tests:   [],
-      compile: false,
-    };
-  }
-
-  // Wrap compiled JS: inject helpers + collect results
-  const wrapped = [
-    TEST_HELPERS,
-    result.output,
-    // Expose all top-level functions for test discovery
-    'module.exports = typeof module !== "undefined" ? (function() {',
-    '  const m = {};',
-    '  // collect test_ functions defined at top level',
-    '  const keys = Object.keys(global).filter(k => k.startsWith("test_") && typeof global[k] === "function");',
-    '  keys.forEach(k => m[k] = global[k]);',
-    '  return m;',
-    '})() : {};',
-  ].join('\n');
-
-  // Better approach: scan compiled JS for function declarations named test_*
-  const fnNames = [];
-  const fnRe = /^function (test_[a-zA-Z0-9_]+)\s*\(/mg;
-  let match;
-  while ((match = fnRe.exec(result.output)) !== null) {
-    fnNames.push(match[1]);
-  }
-
-  // Build runner that calls each test_ function
-  const runner = [
-    TEST_HELPERS,
-    result.output,
-    '',
-    '// ── auto-generated test runner ──',
-    ...fnNames.map(n => `__runTest(${JSON.stringify(n.replace(/^test_/, '').replace(/_/g, ' '))}, ${n});`),
-    'module.exports = { __results };',
-  ].join('\n');
-
-  const tmpPath = path.join(os.tmpdir(), `_flux_test_${Date.now()}.js`);
-  try {
-    fs.writeFileSync(tmpPath, runner, 'utf8');
-    const mod = require(tmpPath);
-    const tests = (mod && mod.__results) ? mod.__results : [];
-    return {
-      file:    path.basename(filePath),
-      tests,
-      compile: true,
-      errors:  [],
-    };
-  } catch (e) {
-    return {
-      file:    path.basename(filePath),
-      tests:   [],
-      compile: false,
-      errors:  [{ message: `Runtime error: ${e.message}` }],
-    };
-  } finally {
-    try { fs.unlinkSync(tmpPath); } catch (_) {}
-  }
-}
-
-function runTests(target, transpile) {
-  let files;
-  try {
-    files = discoverTestFiles(target);
-  } catch (e) {
-    console.error(clr(C.red, `✗ ${e.message}`));
-    process.exit(1);
-  }
-
-  if (files.length === 0) {
-    console.log(clr(C.yellow, `No *.test.flux files found in: ${target}`));
-    return;
-  }
-
-  let totalPass = 0;
-  let totalFail = 0;
-  let totalFiles = 0;
-  const t0 = Date.now();
-
-  for (const file of files) {
-    totalFiles++;
-    console.log(clr(C.cyan, `\n◈ ${path.basename(file)}`));
-
-    const result = runTestFile(file, transpile);
-
-    if (!result.compile) {
-      console.log(clr(C.red, `  ✗ Compile error:`));
-      for (const e of result.errors) {
-        console.log(clr(C.red, `    ${e.message}`));
-      }
-      totalFail++;
-      continue;
-    }
-
-    if (result.tests.length === 0) {
-      console.log(clr(C.yellow, `  (no test_ functions found)`));
-      continue;
-    }
-
-    for (const t of result.tests) {
-      if (t.ok) {
-        totalPass++;
-        console.log(clr(C.green, `  ✓`) + clr(C.gray, ` ${t.name}`));
-      } else {
-        totalFail++;
-        console.log(clr(C.red, `  ✗ ${t.name}`));
-        console.log(clr(C.dim,  `    ${t.error}`));
-      }
-    }
-  }
-
-  const elapsed = Date.now() - t0;
-  const total   = totalPass + totalFail;
-
-  console.log();
-  console.log(clr(C.bold, '─'.repeat(50)));
-  console.log(
-    clr(C.bold, `Results: `) +
-    clr(C.green, `${totalPass} passed`) + clr(C.gray, ', ') +
-    (totalFail > 0 ? clr(C.red, `${totalFail} failed`) : clr(C.gray, `${totalFail} failed`)) +
-    clr(C.gray, ` (${total} total) in ${elapsed}ms`)
-  );
-  console.log();
-
-  if (totalFail > 0) process.exitCode = 1;
-}
-
-module.exports = { runTests, runTestFile, discoverTestFiles };

package/src/transpiler.js

@@ -1,172 +0,0 @@
-'use strict';
-
-const { Lexer }            = require('./lexer');
-const { Parser }           = require('./parser');
-const { CodeGenerator }    = require('./codegen');
-const { SourceMapBuilder } = require('./sourcemap');
-const { transformJsx }     = require('./jsx');
-const { Mangler }          = require('./mangler');
-const { transformCss }     = require('./css-preprocessor');
-const { Checker }          = require('./checker');
-const { FluxTypeChecker }  = require('./type-checker');
-const { buildStdlib, detectUsedSymbols } = require('./stdlib');
-
-/**
- * Transpile Flux source code to JavaScript.
- *
- * @param {string} source      - Flux source code
- * @param {object} [options]
- *   @param {boolean} options.sourcemap   - generate source map
- *   @param {string}  options.sourceFile  - source .flux filename (for source map)
- *   @param {string}  options.outputFile  - output .js filename  (for source map)
- *   @param {boolean} options.mangle      - obfuscate variable/function names
- *   @param {boolean} options.jsx         - enable JSX (default: true)
- *   @param {string}  options.jsxTarget   - 'browser' | 'server' (default: 'browser')
- *   @param {boolean} options.typecheck   - run type checker (default: true)
- *   @param {boolean} options.check       - run val-immutability checker
- *   @param {boolean} options.stdlib      - inject stdlib helpers (default: true)
- * @returns {{ success, output, sourceMap, ast, tokens, errors, typeErrors, typeWarnings, stage, nameMap }}
- */
-function transpile(source, options = {}) {
-  const result = {
-    success:      false,
-    output:       '',
-    sourceMap:    null,
-    ast:          null,
-    tokens:       null,
-    errors:       [],
-    typeErrors:   [],
-    typeWarnings: [],
-    stage:        null,
-    nameMap:      null,
-  };
-
-  try {
-    // ── Stage 0a: CSS Block Preprocessing ────────────────────────────────────
-    result.stage = 'css';
-    const cssProcessed = transformCss(source);
-
-    // ── Stage 0b: JSX Preprocessing ──────────────────────────────────────────
-    result.stage = 'jsx';
-    const jsxTarget  = options.jsxTarget || 'browser';
-    const enableJsx  = options.jsx !== false;
-    let   processedSource = cssProcessed;
-    let   jsxRuntime      = '';
-
-    if (enableJsx) {
-      const jsxResult  = transformJsx(cssProcessed, { target: jsxTarget });
-      processedSource  = jsxResult.source;
-      jsxRuntime       = jsxResult.hasJsx ? jsxResult.runtimeHelpers : '';
-    }
-
-    // ── Stage 1: Lexer ────────────────────────────────────────────────────────
-    result.stage  = 'lexer';
-    const tokens  = new Lexer(processedSource).tokenize();
-    result.tokens = tokens;
-
-    // ── Stage 2: Parser ───────────────────────────────────────────────────────
-    result.stage = 'parser';
-    const ast    = new Parser(tokens).parse();
-    result.ast   = ast;
-
-    // ── Stage 3 (optional): Val-immutability Checker ──────────────────────────
-    if (options.check) {
-      result.stage = 'checker';
-      const checker  = new Checker();
-      const analysis = checker.check(ast);
-      if (analysis.errors.length > 0) {
-        result.errors = analysis.errors;
-        result.stage  = null;
-        return result;
-      }
-      result.typeWarnings = [...(result.typeWarnings || []), ...analysis.warnings];
-    }
-
-    // ── Stage 3b (optional): Type Checker ────────────────────────────────────
-    if (options.typecheck !== false) {
-      result.stage = 'typecheck';
-      const tc = new FluxTypeChecker();
-      const tcResult = tc.check(ast);
-      result.typeErrors   = tcResult.errors;
-      result.typeWarnings = [...(result.typeWarnings || []), ...tcResult.warnings];
-    }
-
-    // ── Stage 4 (optional): Name Mangling ────────────────────────────────────
-    let finalAst = ast;
-    if (options.mangle) {
-      result.stage = 'mangler';
-      const mangler = new Mangler();
-      finalAst      = mangler.mangle(ast);
-      result.nameMap = mangler.getMap();
-    }
-
-    // ── Stage 5: Code Generator ───────────────────────────────────────────────
-    result.stage = 'codegen';
-
-    const genOptions = { indent: options.mangle ? '' : '  ' };
-
-    if (options.sourcemap) {
-      genOptions.smBuilder = new SourceMapBuilder(
-        options.sourceFile || 'source.flux',
-        source
-      );
-    }
-
-    const { code, smBuilder } = new CodeGenerator(genOptions).generate(finalAst);
-
-    // ── Stage 6: Stdlib Injection ────────────────────────────────────────────
-    // Detect which stdlib helpers are needed and prepend them.
-    const injectStdlib = options.stdlib !== false;
-    let stdlibPreamble = '';
-    if (injectStdlib) {
-      const usedSymbols = detectUsedSymbols(code);
-      if (usedSymbols.length > 0) {
-        stdlibPreamble = buildStdlib(usedSymbols) + '\n';
-      }
-    }
-
-    // ── Assemble final output ────────────────────────────────────────────────
-    const runtimePrefix = jsxRuntime ? `// Flux JSX Runtime\n"use strict";\n${jsxRuntime}\n` : '';
-    const cleanCode = jsxRuntime ? code.replace(/^\/\/ Generated.*\n"use strict";\n/, '') : code;
-
-    let finalCode;
-    if (smBuilder) {
-      const outFile    = options.outputFile || 'output.js';
-      const mapFile    = outFile + '.map';
-      result.sourceMap = smBuilder.toString(outFile);
-      finalCode        = runtimePrefix + stdlibPreamble + cleanCode + `\n//# sourceMappingURL=${mapFile}\n`;
-    } else {
-      finalCode = runtimePrefix + stdlibPreamble + cleanCode;
-    }
-
-    if (options.mangle) {
-      const allLines    = finalCode.split('\n').map(l => l.trim()).filter(l => l.length > 0);
-      const headerLines = [];
-      const codeLines   = [];
-      for (const l of allLines) {
-        if (l.startsWith('//') && codeLines.length === 0) headerLines.push(l);
-        else codeLines.push(l);
-      }
-      finalCode = [...headerLines, codeLines.join(' ')].join('\n');
-    }
-
-    result.output  = finalCode;
-    result.success = true;
-    result.stage   = null;
-
-  } catch (e) {
-    result.errors.push({
-      message: e.message,
-      name:    e.name,
-      stage:   result.stage,
-      line:    e.tok ? e.tok.line : (e.line || null),
-      col:     e.tok ? e.tok.col  : (e.col  || null),
-      len:     e.tok && e.tok.value ? String(e.tok.value).length : 1,
-      hint:    e.hint || null,
-    });
-  }
-
-  return result;
-}
-
-module.exports = { transpile };