@xnoxs/flux-lang 4.0.3 → 4.0.5

package/dist/flux.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v4.0.3
+ * flux-lang v4.0.5
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License

package/index.js

@@ -3,17 +3,17 @@
 /**
  * Flux Lang — Public API
  *
- * const { transpile } = require('flux-lang');
- * import { transpile, format, buildStdlib } from 'flux-lang';
+ * const { transpile } = require('@xnoxs/flux-lang');
+ * import { transpile, format, buildStdlib } from '@xnoxs/flux-lang';
  */
 
-const { transpile }                        = require('./src/transpiler');
-const { format }                           = require('./src/formatter');
-const { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS } = require('./src/stdlib');
-const { Lexer }                            = require('./src/lexer');
-const { Parser }                           = require('./src/parser');
-const { bundle }                           = require('./src/bundler');
-const { loadConfig, mergeConfig, defineConfig } = require('./src/config');
+const { transpile }                        = require('./src/self/transpiler');
+const { format }                           = require('./src/self/formatter');
+const { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS } = require('./src/self/stdlib');
+const { Lexer }                            = require('./src/self/lexer');
+const { Parser }                           = require('./src/self/parser');
+const { bundle }                           = require('./src/self/bundler');
+const { loadConfig, mergeConfig }          = require('./src/self/config');
 
 module.exports = {
   transpile,
@@ -26,5 +26,4 @@ module.exports = {
   bundle,
   loadConfig,
   mergeConfig,
-  defineConfig,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
   "main": "dist/flux.cjs.js",
   "module": "dist/flux.esm.js",
@@ -9,9 +9,8 @@
     "flux": "./bin/flux.js"
   },
   "scripts": {
-    "build": "node scripts/build.js",
-    "prepublishOnly": "npm test && npm run build",
-    "test": "node src/cli.js test tests/",
+    "build": "node -e \"console.log(\"build skipped\")\"",
+    "test": "node src/self/cli.js test tests/",
     "test:file": "node src/cli.js test",
     "check": "node src/cli.js check tests/01_basics.test.flux",
     "bench": "node benchmarks/bench.js",
@@ -84,4 +83,4 @@
   "devDependencies": {
     "esbuild": "^0.28.1"
   }
-}
+}

package/src/self/bundler.flux

@@ -3,6 +3,8 @@
 //  src/self/bundler.flux — written in Flux, compiled by stage-0
 //
 //  Bundles multiple Flux modules into a single JS file.
+//  Resolves all inter-file .flux imports recursively.
+//  npm packages (non-relative imports) remain as require() calls.
 // ============================================================
 
 import Fs   from "fs"
@@ -16,17 +18,25 @@ fn toModuleId(absPath):
   return '_flux_' + base.replace(/[^a-zA-Z0-9]/g, '_')
 
 fn extractModuleInfo(ast, fromFile):
-  val imports = []
-  val exports = []
-  val body    = []
-  val dir     = Path.dirname(fromFile)
+  val imports    = []
+  val npmImports = []
+  val exports    = []
+  val body       = []
+  val dir        = Path.dirname(fromFile)
 
   for node in ast.body:
     if node.type == 'ImportDecl':
-      var src = node.source
-      if not src.endsWith('.flux'): src = src + '.flux'
-      val absPath = Path.resolve(dir, src)
-      imports.push({ names: node.names, source: node.source, absPath })
+      val src = node.source
+      // Relative import → resolve as .flux file
+      if src.startsWith('./') or src.startsWith('../'):
+        var resolved = src
+        if not resolved.endsWith('.flux'): resolved = resolved + '.flux'
+        val absPath = Path.resolve(dir, resolved)
+        imports.push({ names: node.names, source: node.source, absPath })
+      else:
+        // npm package import — keep as-is (require in output)
+        npmImports.push({ names: node.names, source: src })
+        body.push(node)
 
     else if node.type == 'ExportDecl':
       val inner = node.decl
@@ -38,7 +48,7 @@ fn extractModuleInfo(ast, fromFile):
     else:
       body.push(node)
 
-  return { cleanAst: { type: 'Program', body }, imports, exports }
+  return { cleanAst: { type: 'Program', body }, imports, npmImports, exports }
 
 fn codegenModule(ast):
   val cg = makeCodeGen({ indent: '    ' })
@@ -80,6 +90,7 @@ export class Bundler:
     val info = extractModuleInfo(ast, absPath)
     self.modules.set(absPath, { cleanAst: info.cleanAst, imports: info.imports, exports: info.exports, source, absPath })
 
+    // Recursively collect all .flux imports
     for imp in info.imports:
       self.collect(imp.absPath)
 
@@ -98,12 +109,6 @@ export class Bundler:
       lines.push('"use strict";')
       lines.push('')
 
-    // flux_modules resolver: patches Module._resolveFilename so require() looks in
-    // flux_modules/node_modules/ first (packages installed via `flux install`).
-    lines.push('// flux_modules resolver')
-    lines.push("(function(){var _p=require('path'),_fs=require('fs'),_M=require('module'),_d=_p.join(process.cwd(),'flux_modules','node_modules');if(_fs.existsSync(_d)){var _o=_M._resolveFilename.bind(_M);_M._resolveFilename=function(r,p,m,op){if(!r.startsWith('.')&&!r.startsWith('/')&&!r.startsWith('node:')){var _fp=_p.join(_d,r.split('/')[0]);if(_fs.existsSync(_fp)){try{return _o(_p.join(_d,r),p,m,op);}catch(_e){}}}return _o(r,p,m,op);};}})();")
-    lines.push('')
-
     lines.push('(function() {')
     lines.push('')
 
@@ -125,7 +130,7 @@ export class Bundler:
       for imp in mod.imports:
         val srcId = toModuleId(imp.absPath)
         for name in imp.names:
-          val localName = name.alias ?? name.name
+          val localName    = name.alias ?? name.name
           val importedName = name.name
           lines.push('    var ' + localName + ' = ' + srcId + '._exports ? ' + srcId + '._exports.' + importedName + ' : ' + srcId + '.' + importedName + ';')
 

package/src/self/bundler.js

@@ -1 +1,185 @@
-function findIndex(arr, fn) { return arr.findIndex(fn); } function join(arr, sep) { return arr.join(sep != null ? sep : ','); } function includes(arr, val) { return arr.includes(val); } function trim(s) { return String(s).trim(); } function startsWith(s, prefix) { return String(s).startsWith(prefix); } function endsWith(s, suffix) { return String(s).endsWith(suffix); } function repeat(s, n) { return String(s).repeat(n); } "use strict"; const Fs = require("fs"); const Path = require("path"); const { lexerize } = require("./lexer"); const { makeParser } = require("./parser"); const { makeCodeGen } = require("./codegen"); function _a(_d) { const base = Path.basename(_d, ".flux"); return ("_flux_" + base.replace(/[^a-zA-Z0-9]/g, "_")); } function _b(_e, _f) { const imports = []; const exports = []; const body = []; const dir = Path.dirname(_f); for (const _g of _e.body) { if ((_g.type == "ImportDecl")) { let src = _g.source; if (!src.endsWith(".flux")) { src = (src + ".flux"); } const _d = Path.resolve(dir, src); imports.push({ names: _g.names, source: _g.source, absPath: _d }); } else if ((_g.type == "ExportDecl")) { const inner = _g.decl; if ((inner.type == "FnDecl")) { exports.push(inner.name); } if ((inner.type == "ClassDecl")) { exports.push(inner.name); } if ((inner.type == "VarDecl")) { exports.push(inner.name); } body.push(inner); } else { body.push(_g); } } return { cleanAst: { type: "Program", body }, imports, exports }; } function _c(_e) { const cg = makeCodeGen({ indent: "    " }); const result = cg.generate(_e); const lines = result.code.split("\n"); const start = lines.findIndex((_h) => (((_h.trim() != "") && !_h.includes("Generated by Flux")) && !_h.includes("\"use strict\""))); return lines.slice(start).join("\n"); } class Bundler { constructor(entryFile, options, modules, order, visited, inStack) { this.entryFile = entryFile; this.options = options; this.modules = modules; this.order = order; this.visited = visited; this.inStack = inStack; } bundle() { this.collect(this.entryFile); return this.link(); } collect(_d) { if (this.visited.has(_d)) { return; } if (this.inStack.has(_d)) { throw new Error(((("[" + Path.basename(_d)) + "] Circular dependency detected: ") + _d)); } if (!Fs.existsSync(_d)) { throw new Error(((("[" + Path.basename(_d)) + "] File not found: ") + _d)); } this.inStack.add(_d); const source = Fs.readFileSync(_d, "utf8"); let _e = null; try { const tokens = lexerize(source).tokenize(); _e = makeParser(tokens).parse(); } catch (_i) { throw new Error(((("[" + Path.basename(_d)) + "] Parse error: ") + _i.message)); } const info = _b(_e, _d); this.modules.set(_d, { cleanAst: info.cleanAst, imports: info.imports, exports: info.exports, source, absPath: _d }); for (const _j of info.imports) { this.collect(_j.absPath); } this.inStack.delete(_d); this.visited.add(_d); this.order.push(_d); } link() { const lines = []; const banner = (this.options.banner != false); if (banner) { lines.push("// Generated by Flux Bundler (self-hosted)"); lines.push(("// Entry: " + Path.basename(this.entryFile))); lines.push(("// Modules: " + this.order.length)); lines.push("\"use strict\";"); lines.push(""); } lines.push("// flux_modules resolver"); lines.push(`(function()${var _p=require('path'),_fs=require('fs'),_M=require('module'),_d=_p.join(process.cwd(),'flux_modules','node_modules');if(_fs.existsSync(_d)){var _o=_M._resolveFilename.bind(_M);_M._resolveFilename=function(r,p,m,op){if(!r.startsWith('.')&&!r.startsWith('/')&&!r.startsWith('_g:')){var _fp=_p.join(_d,r.split('/')[0]);if(_fs.existsSync(_fp)){try{return _o(_p.join(_d,r),p,m,op);}catch(_e){}}}return _o(r,p,m,op);};}})();`); lines.push(""); lines.push("(function() {"); lines.push(""); for (const _d of this.order) { const mod = this.modules.get(_d); const isEntry = (_d == this.entryFile); const modId = _a(_d); const relName = Path.relative(process.cwd(), _d); lines.push(("  // " + "─".repeat(60))); lines.push(("  // Module: " + relName)); lines.push(("  // " + "─".repeat(60))); if (!isEntry) { lines.push((("  var " + modId) + " = (function() {")); lines.push("    var _exports = {};"); lines.push(""); } for (const _j of mod.imports) { const srcId = _a(_j.absPath); for (const _k of _j.names) { const localName = (_k.alias ?? _k.name); const importedName = _k.name; lines.push((((((((((((("    var " + localName) + " = ") + srcId) + "._exports ? ") + srcId) + "._exports.") + importedName) + " : ") + srcId) + ".") + importedName) + ";")); } } if ((mod.imports.length > 0)) { lines.push(""); } const moduleCode = _c(mod.cleanAst); lines.push(moduleCode); if (!isEntry) { if ((mod.exports.length > 0)) { lines.push(""); for (const _l of mod.exports) { lines.push((((("    _exports." + _l) + " = ") + _l) + ";")); } } lines.push(""); lines.push("    return _exports;"); lines.push("  })()"); lines.push((((("  " + modId) + "._exports = ") + modId) + ";")); } lines.push(""); } lines.push("})();"); return { code: lines.join("\n"), modules: this.order.length }; } } module.exports.Bundler = Bundler; function makeBundler(_m, _n) { return new Bundler(Path.resolve(_m), (_n ?? {  }), new Map(), [], new Set(), new Set()); } module.exports.makeBundler = makeBundler; function bundle(_m, _n) { const result = { success: false, code: "", modules: 0, errors: [] }; try { const b = makeBundler(_m, _n); const out = b.bundle(); result.code = out.code; result.modules = out.modules; result.success = true; } catch (_i) { result.errors.push({ message: _i.message, name: _i.name, file: null }); } return result; } module.exports.bundle = bundle;
+/* compiled from src/self/bundler.flux */
+'use strict';
+// Generated by Flux Transpiler v3.5.3 (self-hosted)
+"use strict";
+
+const Fs = require("fs");
+const Path = require("path");
+const { lexerize } = require("./lexer");
+const { makeParser } = require("./parser");
+const { makeCodeGen } = require("./codegen");
+function toModuleId(absPath) {
+  const base = Path.basename(absPath, ".flux");
+  return ("_flux_" + base.replace(/[^a-zA-Z0-9]/g, "_"));
+}
+function extractModuleInfo(ast, fromFile) {
+  const imports = [];
+  const npmImports = [];
+  const exports = [];
+  const body = [];
+  const dir = Path.dirname(fromFile);
+  for (const node of ast.body) {
+    if ((node.type == "ImportDecl")) {
+      const src = node.source;
+      if ((src.startsWith("./") || src.startsWith("../"))) {
+        let resolved = src;
+        if (!resolved.endsWith(".flux")) {
+          resolved = (resolved + ".flux");
+        }
+        const absPath = Path.resolve(dir, resolved);
+        imports.push({ names: node.names, source: node.source, absPath });
+      }
+      else {
+        npmImports.push({ names: node.names, source: src });
+        body.push(node);
+      }
+    }
+    else if ((node.type == "ExportDecl")) {
+      const inner = node.decl;
+      if ((inner.type == "FnDecl")) {
+        exports.push(inner.name);
+      }
+      if ((inner.type == "ClassDecl")) {
+        exports.push(inner.name);
+      }
+      if ((inner.type == "VarDecl")) {
+        exports.push(inner.name);
+      }
+      body.push(inner);
+    }
+    else {
+      body.push(node);
+    }
+  }
+  return { cleanAst: { type: "Program", body }, imports, npmImports, exports };
+}
+function codegenModule(ast) {
+  const cg = makeCodeGen({ indent: "    " });
+  const result = cg.generate(ast);
+  const lines = result.code.split("\n");
+  const start = lines.findIndex((l) => (((l.trim() != "") && !l.includes("Generated by Flux")) && !l.includes("\"use strict\"")));
+  return lines.slice(start).join("\n");
+}
+class Bundler {
+  constructor(entryFile, options, modules, order, visited, inStack) {
+    this.entryFile = entryFile;
+    this.options = options;
+    this.modules = modules;
+    this.order = order;
+    this.visited = visited;
+    this.inStack = inStack;
+  }
+
+  bundle() {
+    this.collect(this.entryFile);
+    return this.link();
+  }
+
+  collect(absPath) {
+    if (this.visited.has(absPath)) {
+      return;
+    }
+    if (this.inStack.has(absPath)) {
+      throw new Error(((("[" + Path.basename(absPath)) + "] Circular dependency detected: ") + absPath));
+    }
+    if (!Fs.existsSync(absPath)) {
+      throw new Error(((("[" + Path.basename(absPath)) + "] File not found: ") + absPath));
+    }
+    this.inStack.add(absPath);
+    const source = Fs.readFileSync(absPath, "utf8");
+    let ast = null;
+    try {
+      const tokens = lexerize(source).tokenize();
+      ast = makeParser(tokens).parse();
+    }
+    catch (e) {
+      throw new Error(((("[" + Path.basename(absPath)) + "] Parse error: ") + e.message));
+    }
+    const info = extractModuleInfo(ast, absPath);
+    this.modules.set(absPath, { cleanAst: info.cleanAst, imports: info.imports, exports: info.exports, source, absPath });
+    for (const imp of info.imports) {
+      this.collect(imp.absPath);
+    }
+    this.inStack.delete(absPath);
+    this.visited.add(absPath);
+    this.order.push(absPath);
+  }
+
+  link() {
+    const lines = [];
+    const banner = (this.options.banner != false);
+    if (banner) {
+      lines.push("// Generated by Flux Bundler (self-hosted)");
+      lines.push(("// Entry: " + Path.basename(this.entryFile)));
+      lines.push(("// Modules: " + this.order.length));
+      lines.push("\"use strict\";");
+      lines.push("");
+    }
+    lines.push("(function() {");
+    lines.push("");
+    for (const absPath of this.order) {
+      const mod = this.modules.get(absPath);
+      const isEntry = (absPath == this.entryFile);
+      const modId = toModuleId(absPath);
+      const relName = Path.relative(process.cwd(), absPath);
+      lines.push(("  // " + "─".repeat(60)));
+      lines.push(("  // Module: " + relName));
+      lines.push(("  // " + "─".repeat(60)));
+      if (!isEntry) {
+        lines.push((("  var " + modId) + " = (function() {"));
+        lines.push("    var _exports = {};");
+        lines.push("");
+      }
+      for (const imp of mod.imports) {
+        const srcId = toModuleId(imp.absPath);
+        for (const name of imp.names) {
+          const localName = (name.alias ?? name.name);
+          const importedName = name.name;
+          lines.push((((((((((((("    var " + localName) + " = ") + srcId) + "._exports ? ") + srcId) + "._exports.") + importedName) + " : ") + srcId) + ".") + importedName) + ";"));
+        }
+      }
+      if ((mod.imports.length > 0)) {
+        lines.push("");
+      }
+      const moduleCode = codegenModule(mod.cleanAst);
+      lines.push(moduleCode);
+      if (!isEntry) {
+        if ((mod.exports.length > 0)) {
+          lines.push("");
+          for (const expName of mod.exports) {
+            lines.push((((("    _exports." + expName) + " = ") + expName) + ";"));
+          }
+        }
+        lines.push("");
+        lines.push("    return _exports;");
+        lines.push("  })()");
+        lines.push((((("  " + modId) + "._exports = ") + modId) + ";"));
+      }
+      lines.push("");
+    }
+    lines.push("})();");
+    return { code: lines.join("\n"), modules: this.order.length };
+  }
+
+}
+
+module.exports.Bundler = Bundler;
+function makeBundler(entryFile, options) {
+  return new Bundler(Path.resolve(entryFile), (options ?? {  }), new Map(), [], new Set(), new Set());
+}
+module.exports.makeBundler = makeBundler;
+function bundle(entryFile, options) {
+  const result = { success: false, code: "", modules: 0, errors: [] };
+  try {
+    const b = makeBundler(entryFile, options);
+    const out = b.bundle();
+    result.code = out.code;
+    result.modules = out.modules;
+    result.success = true;
+  }
+  catch (e) {
+    result.errors.push({ message: e.message, name: e.name, file: null });
+  }
+  return result;
+}
+module.exports.bundle = bundle;