@xnoxs/flux-lang 4.0.9 → 4.1.1

package/dist/transpiler.js

@@ -0,0 +1,4 @@
+'use strict';
+// Compatibility shim — redirects require('./transpiler') to the main CJS bundle.
+// Required by the CLI test-runner which resolves module paths from __dirname.
+module.exports = require('./flux.cjs.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "4.0.9",
+  "version": "4.1.1",
   "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",

package/src/config.js

@@ -1,101 +1,116 @@
-/* compiled from src/self/config.flux by Flux Lang */
 'use strict';
-// ── Flux stdlib ──
 
-function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+/**
+ * Flux Lang — Project Config Loader
+ *
+ * Looks for flux.config.js (or .fluxrc.js) in the current working directory.
+ * Returns a plain object with config values; returns {} if no config found.
+ *
+ * Config schema:
+ *   module.exports = {
+ *     jsxTarget : 'browser' | 'server' | 'react',  // default: 'browser'
+ *     outDir    : './dist',      // output dir for compiled files
+ *     sourcemap : false,         // generate .js.map files
+ *     mangle    : true,          // obfuscate variable/function names
+ *     ignore    : [],            // glob patterns to skip in `flux test`
+ *     entry     : 'src/main.flux', // default bundle entry
+ *   }
+ *
+ * CLI flags always take precedence over config values.
+ */
 
-function includes(arr, val) { return arr.includes(val); }
+const fs   = require('fs');
+const path = require('path');
 
-function keys(obj) { return Object.keys(obj); }
+const CONFIG_NAMES = [
+  'flux.config.js',
+  'flux.config.cjs',
+  '.fluxrc.js',
+];
 
-function endsWith(s, suffix) { return String(s).endsWith(suffix); }
-// ── end stdlib ──
+/**
+ * Load project config from CWD (or a given directory).
+ * @param {string} [cwd] - directory to search (default: process.cwd())
+ * @returns {object} raw config object (or {} if none found)
+ */
+function loadConfig(cwd) {
+  const dir = cwd || process.cwd();
 
-// Generated by Flux Transpiler v3.2.0
-"use strict";
+  for (const name of CONFIG_NAMES) {
+    const configPath = path.join(dir, name);
+    if (!fs.existsSync(configPath)) continue;
+
+    // Bust require cache so tests can reload different configs
+    delete require.cache[require.resolve(configPath)];
 
-const Fs = require("fs");
-const Path = require("path");
-const DEFAULT_CONFIG = { entry: "src/main.flux", outDir: "dist", sourcemap: false, mangle: false, jsx: false, jsxTarget: "browser", typecheck: true, strict: false, watch: false, ignore: [], selfHosted: false, registry: "https://registry.flux-lang.dev", pkg: { name: "", version: "1.0.0", description: "", author: "", license: "MIT", deps: {  }, devDeps: {  } } };
-module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
-function loadConfig(cwd_) {
-  const cwd = (cwd_ ?? process.cwd());
-  const jsonPath = Path.join(cwd, "flux.json");
-  if (Fs.existsSync(jsonPath)) {
-    try {
-      const raw = Fs.readFileSync(jsonPath, "utf8");
-      const parsed = JSON.parse(raw);
-      return mergeConfig(DEFAULT_CONFIG, parsed);
-    }
-    catch (e) {
-      throw new Error(("Invalid flux.json: " + e.message));
-    }
-  }
-  const jsPath = Path.join(cwd, "flux.config.js");
-  if (Fs.existsSync(jsPath)) {
     try {
-      const loaded = require(jsPath);
-      return mergeConfig(DEFAULT_CONFIG, loaded);
-    }
-    catch (e2) {
-      throw new Error(("Invalid flux.config.js: " + e2.message));
-    }
-  }
-  return { ...DEFAULT_CONFIG };
-}
-module.exports.loadConfig = loadConfig;
-function mergeConfig(base, overrides) {
-  if (!overrides) {
-    return { ...base };
-  }
-  const result = { ...base };
-  for (const key of Object.keys(overrides)) {
-    const val_ = overrides[key];
-    if (((val_ != null) && (val_ != undefined))) {
-      result[key] = val_;
+      const raw = require(configPath);
+      const cfg = raw && raw.default ? raw.default : raw;
+
+      if (typeof cfg !== 'object' || cfg === null) {
+        process.stderr.write(
+          `[flux] warning: ${name} must export a plain object — ignoring\n`
+        );
+        return {};
+      }
+
+      return cfg;
+    } catch (e) {
+      process.stderr.write(
+        `[flux] error loading ${name}: ${e.message}\n`
+      );
+      return {};
     }
   }
-  return result;
+
+  return {};
 }
-module.exports.mergeConfig = mergeConfig;
-function writeConfig(config, cwd_) {
-  const cwd = (cwd_ ?? process.cwd());
-  const jsonPath = Path.join(cwd, "flux.json");
-  const content = (JSON.stringify(config, null, 2) + "\n");
-  Fs.writeFileSync(jsonPath, content, "utf8");
+
+/**
+ * Merge file config with CLI opts (CLI flags win).
+ * @param {object} fileConfig  - from loadConfig()
+ * @param {object} cliOpts     - parsed CLI flags
+ * @returns {object} merged options safe to pass to transpile()
+ */
+function mergeConfig(fileConfig, cliOpts) {
+  const cfg = fileConfig || {};
+  const cli = cliOpts   || {};
+
+  return {
+    jsxTarget : cli.jsxTarget  !== undefined ? cli.jsxTarget  : (cfg.jsxTarget  || 'browser'),
+    outDir    : cli.outDir     !== undefined ? cli.outDir     : (cfg.outDir     || null),
+    sourcemap : cli.sourcemap  !== undefined ? cli.sourcemap  : (cfg.sourcemap  || false),
+    mangle    : cli.mangle     !== undefined ? cli.mangle     : (cfg.mangle     !== undefined ? cfg.mangle : true),
+    ignore    : cli.ignore     !== undefined ? cli.ignore     : (cfg.ignore     || []),
+    entry     : cli.entry      !== undefined ? cli.entry      : (cfg.entry      || null),
+  };
 }
-module.exports.writeConfig = writeConfig;
-function validateConfig(config) {
-  const errors = [];
-  if ((config.entry && !config.entry.endsWith(".flux"))) {
-    errors.push("entry must be a .flux file");
-  }
-  if ((config.jsxTarget && !["browser", "server", "react"].includes(config.jsxTarget))) {
-    errors.push("jsxTarget must be 'browser', 'server', or 'react'");
-  }
-  return { valid: (errors.length == 0), errors };
+
+/**
+ * Identity helper for IDE type-checking / autocompletion.
+ * Usage in flux.config.js:  const { defineConfig } = require('@xnoxs/flux-lang/config');
+ * @param {object} config
+ * @returns {object}
+ */
+function defineConfig(config) {
+  return config;
 }
-module.exports.validateConfig = validateConfig;
-function readPackage(cwd_) {
-  const cwd = (cwd_ ?? process.cwd());
-  const fluxJson = Path.join(cwd, "flux.json");
-  const pkgJson = Path.join(cwd, "package.json");
-  if (Fs.existsSync(fluxJson)) {
-    try {
-      return JSON.parse(Fs.readFileSync(fluxJson, "utf8"));
-    }
-    catch (e) {
-      return null;
-    }
-  }
-  if (Fs.existsSync(pkgJson)) {
-    try {
-      return JSON.parse(Fs.readFileSync(pkgJson, "utf8"));
-    }
-    catch (e2) {
-      return null;
-    }
+
+/**
+ * Minimal glob-pattern matcher (also used by test-runner shim to avoid circular require).
+ */
+function matchIgnore(filePath, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  const normalize = p => p.replace(/\\/g, '/');
+  const fp = normalize(filePath);
+  for (const pattern of patterns) {
+    let re = normalize(pattern).replace(/\*\*/g, '\x00DS\x00');
+    re = re.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    re = re.replace(/\*/g, '[^/]*');
+    re = re.replace(/\x00DS\x00\//g, '(.+/)?').replace(/\x00DS\x00/g, '.*');
+    if (new RegExp('(^|/)' + re + '$').test(fp)) return true;
   }
-  return null;
+  return false;
 }
-module.exports.readPackage = readPackage;
+
+module.exports = { loadConfig, mergeConfig, defineConfig, matchIgnore };

package/src/formatter.js

@@ -1,135 +1,140 @@
-/* compiled from src/self/formatter.flux by Flux Lang */
 'use strict';
-// ── Flux stdlib ──
 
-function map(arr, fn) { return arr.map(fn); }
+// ── Flux Code Formatter ───────────────────────────────────────────────────────
+// Normalizes Flux source code:
+//   • 4-space indentation
+//   • Strips trailing whitespace
+//   • Max 1 consecutive blank line
+//   • Blank line after top-level fn/class/type declarations
+//   • Spacing around binary operators
+//   • Consistent colon / arrow spacing
 
-function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
-
-function max(arr) {
-  if (arguments.length > 1) return Math.max.apply(null, arguments);
-  return Math.max.apply(null, arr);
-}
-
-function round(n, decimals) {
-  if (decimals == null) return Math.round(n);
-  var f = Math.pow(10, decimals);
-  return Math.round(n * f) / f;
-}
-
-function trimStart(s) { return String(s).trimStart(); }
-
-function trimEnd(s) { return String(s).trimEnd(); }
-
-function startsWith(s, prefix) { return String(s).startsWith(prefix); }
-
-function repeat(s, n) { return String(s).repeat(n); }
-// ── end stdlib ──
-
-// Generated by Flux Transpiler v3.2.0
-"use strict";
-
-function normalizeOperators(line) {
-  if (((line.match(/:/g) ?? []).length > 2)) {
-    return line;
-  }
-  let result = line;
-  result = result.replace(/([^=!<>+\-*\/%])=(?!=|>)/g, "$1 = ");
-  result = result.replace(/\s{2,}=/g, " =");
-  result = result.replace(/([^\s])  +/g, "$1 ");
-  result = result.replace(/,(?!\s)/g, ", ");
-  result = result.replace(/\s*->\s*/g, " -> ");
-  result = result.replace(/\s*=>\s*/g, " => ");
-  result = result.trimEnd();
-  return result;
-}
 function format(source) {
-  const lines = source.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const lines = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+
+  // ── 1. Detect indentation unit from the first indented line ─────────────
   let indentUnit = 4;
   for (const line of lines) {
     const m = line.match(/^( +)\S/);
     if (m) {
       const w = m[1].length;
-      if (((w > 0) && (w < indentUnit))) {
-        indentUnit = w;
-      }
+      if (w > 0 && w < indentUnit) indentUnit = w;
       break;
     }
   }
-  if ((indentUnit < 1)) {
-    indentUnit = 4;
-  }
-  function normalizeLine(line) {
+  if (indentUnit < 1) indentUnit = 4;
+
+  // ── 2. Strip trailing whitespace + normalize indent to 4 spaces ─────────
+  const normalized = lines.map(line => {
     const stripped = line.trimEnd();
-    if (!stripped) {
-      return "";
-    }
-    const m2 = stripped.match(/^( *)/);
-    const spaces = (m2 ? m2[1].length : 0);
-    const level = Math.round((spaces / indentUnit));
+    if (!stripped) return '';
+    const m = stripped.match(/^( *)/);
+    const spaces = m ? m[1].length : 0;
+    const level  = Math.round(spaces / indentUnit);
     const content = stripped.trimStart();
-    let formatted = normalizeOperators(content);
-    if ((content.startsWith("//") || content.startsWith("*"))) {
-      formatted = content;
-    }
-    return ("    ".repeat(level) + formatted);
-  }
-  const normalized = lines.map((line) => normalizeLine(line));
+
+    // Normalize spacing around operators in the content (only when not a string literal line)
+    const formatted = content.startsWith('//') || content.startsWith('*')
+      ? content
+      : normalizeOperators(content);
+
+    return '    '.repeat(level) + formatted;
+  });
+
+  // ── 3. Collapse multiple blank lines → max 1 ────────────────────────────
   const collapsed = [];
   let blankRun = 0;
   for (const line of normalized) {
-    if ((line == "")) {
-      blankRun = (blankRun + 1);
-      if ((blankRun <= 1)) {
-        collapsed.push("");
-      }
-    }
-    else {
+    if (line === '') {
+      blankRun++;
+      if (blankRun <= 1) collapsed.push('');
+    } else {
       blankRun = 0;
       collapsed.push(line);
     }
   }
+
+  // ── 4. Add blank line after top-level fn/class/type/async fn blocks ──────
   const withSpacing = [];
-  let i = 0;
-  while ((i < collapsed.length)) {
+  for (let i = 0; i < collapsed.length; i++) {
     withSpacing.push(collapsed[i]);
-    const indent = (collapsed[i].match(/^( *)/) ?? ["", ""])[1].length;
-    if ((i > 0)) {
-      const prevIndent = (collapsed[(i - 1)].match(/^( *)/) ?? ["", ""])[1].length;
-      const cur = collapsed[i].trimStart();
-      if ((((prevIndent >= 4) && (indent == 0)) && (cur != ""))) {
-        if ((withSpacing[(withSpacing.length - 2)] != "")) {
-          withSpacing.splice((withSpacing.length - 1), 0, "");
+    const cur  = collapsed[i].trimStart();
+    const next = (collapsed[i + 1] || '').trimStart();
+    const indent = collapsed[i].match(/^( *)/)[1].length;
+
+    // After dedented fn/class/type at indent=0 or indent=4, add blank line
+    if (indent <= 4 && /^(fn |async fn |class |type )/.test(cur)) {
+      // No blank needed if next line is blank already
+      if (next !== '' && !/^(fn |async fn |class |type )/.test(next)) {
+        // skip — next content comes right after declaration line, part of fn
+      }
+    }
+
+    // After closing a fn/class block at top level (no indent dedent signal,
+    // but we detect when a non-indented line follows an indented block)
+    if (i > 0) {
+      const prevIndent = collapsed[i - 1].match(/^( *)/)[1].length;
+      if (prevIndent >= 4 && indent === 0 && cur !== '') {
+        // We just came back to top-level — add blank if last added wasn't blank
+        if (withSpacing[withSpacing.length - 2] !== '') {
+          withSpacing.splice(withSpacing.length - 1, 0, '');
         }
       }
     }
-    i = (i + 1);
   }
+
+  // ── 5. Trim leading/trailing blank lines + ensure single trailing newline ─
   let out = withSpacing;
-  while (((out.length > 0) && (out[0] == ""))) {
-    out.shift();
-  }
-  while (((out.length > 0) && (out[(out.length - 1)] == ""))) {
-    out.pop();
-  }
-  out.push("");
-  return out.join("\n");
+  while (out.length > 0 && out[0] === '') out.shift();
+  while (out.length > 0 && out[out.length - 1] === '') out.pop();
+  out.push('');
+
+  return out.join('\n');
+}
+
+// ── Operator spacing normalizer ──────────────────────────────────────────────
+// Ensures spaces around binary operators without touching strings/comments
+function normalizeOperators(line) {
+  // Skip lines that look like CSS / strings (heuristic: too many : or { })
+  if ((line.match(/:/g) || []).length > 2) return line;
+
+  let result = line;
+
+  // Add space around = (but not ==, !=, <=, >=, ->, =>, +=, -=, *=, /=, %=)
+  result = result.replace(/([^=!<>+\-*/%])=(?!=|>)/g, '$1 = ');
+  result = result.replace(/\s{2,}=/g, ' =');
+
+  // Normalize multiple spaces inside (but not at start = indentation)
+  result = result.replace(/([^\s])  +/g, '$1 ');
+
+  // Ensure space after comma
+  result = result.replace(/,(?!\s)/g, ', ');
+
+  // Ensure space before/after -> and =>
+  result = result.replace(/\s*->\s*/g, ' -> ');
+  result = result.replace(/\s*=>\s*/g, ' => ');
+
+  // Trim end
+  result = result.trimEnd();
+
+  return result;
 }
-module.exports.format = format;
+
+// ── Diff output ──────────────────────────────────────────────────────────────
 function diff(original, formatted) {
-  const origLines = original.split("\n");
-  const fmtLines = formatted.split("\n");
-  const changes = [];
+  const origLines = original.split('\n');
+  const fmtLines  = formatted.split('\n');
+  const changes   = [];
+
   const maxLen = Math.max(origLines.length, fmtLines.length);
-  let j = 0;
-  while ((j < maxLen)) {
-    const o = origLines[j];
-    const f = fmtLines[j];
-    if ((o != f)) {
-      changes.push({ line: (j + 1), original: o, formatted: f });
+  for (let i = 0; i < maxLen; i++) {
+    const o = origLines[i];
+    const f = fmtLines[i];
+    if (o !== f) {
+      changes.push({ line: i + 1, original: o, formatted: f });
     }
-    j = (j + 1);
   }
   return changes;
 }
-module.exports.diff = diff;
+
+module.exports = { format, diff };