@xnoxs/flux-lang 3.1.1

package/index.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Flux Lang — TypeScript Definitions
+ * Transpiler API for embedding Flux compilation in TypeScript/JavaScript projects.
+ */
+
+export interface TranspileError {
+  /** Human-readable error description */
+  message: string;
+  /** Error category name (e.g. "SyntaxError", "TypeError", "CodeGenError") */
+  name?: string;
+  /** Compilation stage where the error occurred */
+  stage?: 'css' | 'jsx' | 'lexer' | 'parser' | 'checker' | 'typecheck' | 'mangler' | 'codegen';
+  /** 1-based line number in the source file */
+  line?: number;
+  /** 1-based column number in the source file */
+  col?: number;
+  /** Optional hint for fixing the error */
+  hint?: string;
+}
+
+export interface TranspileWarning {
+  message: string;
+  line?: number;
+  col?: number;
+  hint?: string;
+}
+
+export interface TranspileOptions {
+  /**
+   * Generate an inline source map.
+   * The map URL is appended as `//# sourceMappingURL=<outputFile>.map`
+   * @default false
+   */
+  sourcemap?: boolean;
+
+  /**
+   * The name of the source `.flux` file — used in source map metadata.
+   * @default 'source.flux'
+   */
+  sourceFile?: string;
+
+  /**
+   * The name of the output `.js` file — used in source map metadata.
+   * @default 'output.js'
+   */
+  outputFile?: string;
+
+  /**
+   * Mangle (obfuscate) variable and function names in the output.
+   * @default false
+   */
+  mangle?: boolean;
+
+  /**
+   * Enable JSX transformation.
+   * @default true
+   */
+  jsx?: boolean;
+
+  /**
+   * JSX output target.
+   * - `'browser'` — uses `document.createElement` and `appendChild`
+   * - `'server'`  — produces HTML strings
+   * @default 'browser'
+   */
+  jsxTarget?: 'browser' | 'server';
+
+  /**
+   * Run the static type checker and attach results to `typeErrors` / `typeWarnings`.
+   * @default true
+   */
+  typecheck?: boolean;
+
+  /**
+   * Run the val-immutability checker (ensures `val` bindings are not reassigned).
+   * @default false
+   */
+  check?: boolean;
+}
+
+export interface TranspileResult {
+  /** Whether compilation succeeded without errors */
+  success: boolean;
+
+  /** The compiled JavaScript code (empty string on failure) */
+  output: string;
+
+  /** Source map JSON string, or `null` if `sourcemap` option was not set */
+  sourceMap: string | null;
+
+  /** The Abstract Syntax Tree produced by the parser */
+  ast: object | null;
+
+  /** The token stream produced by the lexer */
+  tokens: object[] | null;
+
+  /** Syntax / code generation errors that caused compilation to fail */
+  errors: TranspileError[];
+
+  /** Type errors from the static type checker (does not halt compilation) */
+  typeErrors: TranspileError[];
+
+  /** Type warnings from the static type checker */
+  typeWarnings: TranspileWarning[];
+
+  /**
+   * The last stage that was executing when an error occurred, or `null` on success.
+   */
+  stage: 'css' | 'jsx' | 'lexer' | 'parser' | 'checker' | 'typecheck' | 'mangler' | 'codegen' | null;
+
+  /**
+   * Name mangling map — maps original names to mangled names.
+   * Only populated when `mangle: true`.
+   */
+  nameMap: Record<string, string> | null;
+}
+
+/**
+ * Transpile a Flux source string to JavaScript.
+ *
+ * @example
+ * ```ts
+ * import { transpile } from 'flux-lang';
+ *
+ * const result = transpile('val x = 42\nprint(x)');
+ * if (result.success) {
+ *   console.log(result.output); // → "const x = 42;\nconsole.log(x);"
+ * } else {
+ *   console.error(result.errors);
+ * }
+ * ```
+ */
+export declare function transpile(source: string, options?: TranspileOptions): TranspileResult;
+
+
+// ── Stdlib types ─────────────────────────────────────────────────────────────
+
+/** Detect which Flux stdlib symbols are referenced in a JS code string. */
+export declare function detectUsedSymbols(jsCode: string): string[];
+
+/** Build the stdlib preamble JavaScript string. */
+export declare function buildStdlib(symbols?: string[]): string;
+
+/** All available Flux stdlib symbol names. */
+export declare const STDLIB_SYMBOLS: readonly string[];
+
+
+// ── Formatter ────────────────────────────────────────────────────────────────
+
+/**
+ * Format Flux source code.
+ * Normalizes indentation, blank lines, and operator spacing.
+ */
+export declare function format(source: string): string;
+
+
+// ── Lexer ────────────────────────────────────────────────────────────────────
+
+export interface Token {
+  type: string;
+  value: string | number | boolean | null;
+  line: number;
+  col: number;
+}
+
+export declare class Lexer {
+  constructor(source: string);
+  tokenize(): Token[];
+}
+
+
+// ── Parser ───────────────────────────────────────────────────────────────────
+
+export interface AstNode {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface Program {
+  type: 'Program';
+  body: AstNode[];
+}
+
+export declare class Parser {
+  constructor(tokens: Token[]);
+  parse(): Program;
+}
+
+
+// ── Bundler ──────────────────────────────────────────────────────────────────
+
+export interface BundleResult {
+  success: boolean;
+  code: string;
+  modules: number;
+  errors: TranspileError[];
+}
+
+/**
+ * Bundle a Flux entry file and all its imports into a single JavaScript file.
+ */
+export declare function bundle(entryPath: string, options?: { minify?: boolean }): BundleResult;

package/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+ * Flux Lang — Public API
+ *
+ * const { transpile } = require('flux-lang');
+ * import { transpile, format, buildStdlib } from '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');
+
+module.exports = {
+  transpile,
+  format,
+  buildStdlib,
+  detectUsedSymbols,
+  STDLIB_SYMBOLS,
+  Lexer,
+  Parser,
+  bundle,
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@xnoxs/flux-lang",
+  "version": "3.1.1",
+  "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "flux": "./bin/flux.js"
+  },
+  "scripts": {
+    "build":     "node scripts/build.js",
+    "prepublishOnly": "npm test && npm run build",
+    "test":      "node bin/flux.js test tests/",
+    "test:file": "node bin/flux.js test",
+    "check":     "node bin/flux.js check tests/01_basics.test.flux",
+    "bench":     "node benchmarks/bench.js",
+    "start":     "node bin/flux.js run app/server.flux",
+    "repl":      "node bin/flux.js repl",
+    "version":   "node bin/flux.js version"
+  },
+  "exports": {
+    ".":          "./index.js",
+    "./stdlib":   "./src/stdlib.js",
+    "./formatter":"./src/formatter.js",
+    "./dist/cjs": "./dist/flux.cjs.js",
+    "./dist/esm": "./dist/flux.esm.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "dist/",
+    "scripts/build.js",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "transpiler",
+    "compiler",
+    "language",
+    "javascript",
+    "flux",
+    "flux-lang",
+    "async",
+    "functional",
+    "pattern-matching",
+    "type-safe",
+    "scripting",
+    "frontend",
+    "backend",
+    "jsx",
+    "algebraic-types"
+  ],
+  "author": "Flux Lang Contributors",
+  "license": "MIT",
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flux-lang/flux-lang.git"
+  },
+  "bugs": {
+    "url": "https://github.com/flux-lang/flux-lang/issues"
+  },
+  "homepage": "https://flux-lang.dev",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/flux-lang"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.1"
+  }
+}

package/scripts/build.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Flux Lang — esbuild bundle script
+ *
+ * Produces:
+ *   dist/flux.cjs.js   — CommonJS bundle (Node, require())
+ *   dist/flux.esm.js   — ESM bundle (import / bundlers)
+ *   dist/flux.min.js   — Minified CJS bundle (browser / CDN)
+ *
+ * Usage:
+ *   node scripts/build.js
+ */
+
+const esbuild = require('esbuild');
+const fs      = require('fs');
+const path    = require('path');
+
+const pkg    = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+const banner = `/*!
+ * flux-lang v${pkg.version}
+ * ${pkg.description}
+ * (c) ${new Date().getFullYear()} Flux Lang Contributors
+ * Released under the ${pkg.license} License
+ */`;
+
+const outDir = path.resolve(__dirname, '../dist');
+if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+const shared = {
+  entryPoints: ['index.js'],
+  bundle:      true,
+  platform:    'node',
+  target:      ['node16'],
+  external:    ['esbuild'],    // esbuild stays dev-only
+  banner:      { js: banner },
+};
+
+async function build() {
+  const start = Date.now();
+
+  await Promise.all([
+    // CJS bundle (for Node require())
+    esbuild.build({
+      ...shared,
+      format:  'cjs',
+      outfile: 'dist/flux.cjs.js',
+    }),
+
+    // ESM bundle (for modern bundlers / type:"module" projects)
+    esbuild.build({
+      ...shared,
+      format:  'esm',
+      outfile: 'dist/flux.esm.js',
+    }),
+
+    // Minified CJS (CDN / browser via require shim)
+    esbuild.build({
+      ...shared,
+      format:   'cjs',
+      minify:   true,
+      outfile:  'dist/flux.min.js',
+    }),
+  ]);
+
+  const sizes = ['dist/flux.cjs.js', 'dist/flux.esm.js', 'dist/flux.min.js'].map(f => {
+    const bytes = fs.statSync(f).size;
+    const kb    = (bytes / 1024).toFixed(1);
+    return `  ${f.padEnd(22)} ${kb} kB`;
+  });
+
+  console.log(`\nBuild complete in ${Date.now() - start}ms\n${sizes.join('\n')}\n`);
+}
+
+build().catch(e => { console.error(e); process.exit(1); });

package/src/bundler.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { Lexer }         = require('./lexer');
+const { Parser }        = require('./parser');
+const { CodeGenerator } = require('./codegen');
+
+class BundleError extends Error {
+  constructor(msg, file) {
+    super(file ? `[${path.basename(file)}] ${msg}` : msg);
+    this.name     = 'BundleError';
+    this.file     = file;
+  }
+}
+
+// ── AST transformation helpers ────────────────────────────────────────────────
+
+// Hapus node ImportDeclaration dan ExportDeclaration dari body AST
+// Kembalikan: { cleanAst, imports, exports }
+function extractModuleInfo(ast, fromFile) {
+  const imports = []; // { names: [], source, absPath }
+  const exports = []; // nama yang diekspor
+  const body    = [];
+  const dir     = path.dirname(fromFile);
+
+  for (const node of ast.body) {
+    if (node.type === 'ImportDecl') {
+      let src = node.source;
+      if (!src.endsWith('.flux')) src += '.flux';
+      const absPath = path.resolve(dir, src);
+      imports.push({ names: node.names, source: node.source, absPath });
+
+    } 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, exports };
+}
+
+// Hasilkan kode JS dari clean AST
+function codegenModule(ast) {
+  const { code } = new CodeGenerator({ indent: '    ' }).generate(ast);
+  // Hapus header boilerplate dari tiap modul (dua baris pertama)
+  const lines = code.split('\n');
+  // Hapus "// Dihasilkan oleh Flux Transpiler", '"use strict";', dan baris kosong pertama
+  const start = lines.findIndex(l => l.trim() !== '' && !l.includes('Dihasilkan') && !l.includes('"use strict"'));
+  return lines.slice(start).join('\n');
+}
+
+// Konversi nama modul (path) ke identifier JS yang aman
+function toModuleId(absPath) {
+  const base = path.basename(absPath, '.flux');
+  return '_flux_' + base.replace(/[^a-zA-Z0-9]/g, '_');
+}
+
+// ── Bundler class ─────────────────────────────────────────────────────────────
+
+class Bundler {
+  constructor(entryFile, options = {}) {
+    this.entryFile  = path.resolve(entryFile);
+    this.options    = options;
+    this.modules    = new Map();  // absPath → { ast, imports, exports, source }
+    this.order      = [];         // topological order (dependencies first)
+    this.visited    = new Set();
+    this.inStack    = new Set();  // cycle detection
+  }
+
+  bundle() {
+    this.collect(this.entryFile);
+    return this.link();
+  }
+
+  // ── Fase 1: Kumpulkan semua modul secara rekursif ─────────────────
+  collect(absPath) {
+    if (this.visited.has(absPath)) return;
+    if (this.inStack.has(absPath)) {
+      throw new BundleError(`Dependensi sirkular terdeteksi: ${absPath}`, absPath);
+    }
+    if (!fs.existsSync(absPath)) {
+      throw new BundleError(`File tidak ditemukan: ${absPath}`, absPath);
+    }
+
+    this.inStack.add(absPath);
+
+    const source = fs.readFileSync(absPath, 'utf8');
+
+    // Lex + Parse
+    let ast;
+    try {
+      const tokens = new Lexer(source).tokenize();
+      ast          = new Parser(tokens).parse();
+    } catch (e) {
+      throw new BundleError(`Error saat parsing: ${e.message}`, absPath);
+    }
+
+    const { cleanAst, imports, exports } = extractModuleInfo(ast, absPath);
+    this.modules.set(absPath, { cleanAst, imports, exports, source, absPath });
+
+    // Proses dependensi dulu (DFS)
+    for (const imp of imports) {
+      this.collect(imp.absPath);
+    }
+
+    this.inStack.delete(absPath);
+    this.visited.add(absPath);
+    this.order.push(absPath); // entry ditambahkan terakhir
+  }
+
+  // ── Fase 2: Link semua modul menjadi satu file JS ─────────────────
+  link() {
+    const lines  = [];
+    const banner = this.options.banner !== false;
+
+    if (banner) {
+      lines.push('// Dihasilkan oleh Flux Bundler');
+      lines.push(`// Entry: ${path.basename(this.entryFile)}`);
+      lines.push(`// Modul: ${this.order.length}`);
+      lines.push('"use strict";');
+      lines.push('');
+    }
+
+    lines.push('(function() {');
+    lines.push('');
+
+    for (const absPath of this.order) {
+      const { cleanAst, imports, exports } = 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(`  // Modul: ${relName}`);
+      lines.push(`  // ${'─'.repeat(60)}`);
+
+      if (!isEntry) {
+        // Bungkus modul non-entry dalam object exports
+        lines.push(`  var ${modId} = (function() {`);
+        lines.push(`    var _exports = {};`);
+        lines.push('');
+      }
+
+      // Inject import bindings dari modul lain
+      for (const imp of imports) {
+        const srcId = toModuleId(imp.absPath);
+        if (imp.names.length === 1) {
+          // import defaultExport from "./mod"
+          lines.push(`    var ${imp.names[0]} = ${srcId};`);
+        } else {
+          // import { a, b } from "./mod"
+          for (const name of imp.names) {
+            lines.push(`    var ${name} = ${srcId}._exports ? ${srcId}._exports.${name} : ${srcId}.${name};`);
+          }
+        }
+      }
+
+      if (imports.length > 0) lines.push('');
+
+      // Kode modul yang sudah dibersihkan
+      const moduleCode = codegenModule(cleanAst);
+      lines.push(moduleCode);
+
+      if (!isEntry) {
+        // Registrasikan semua export ke object _exports
+        if (exports.length > 0) {
+          lines.push('');
+          for (const expName of 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 };
+  }
+}
+
+/**
+ * Bundle beberapa file Flux menjadi satu JS.
+ * @param {string} entryFile - path ke file .flux utama
+ * @param {object} options
+ * @returns {{ success, code, modules, errors }}
+ */
+function bundle(entryFile, options = {}) {
+  const result = { success: false, code: '', modules: 0, errors: [] };
+
+  try {
+    const bundler      = new Bundler(entryFile, options);
+    const { code, modules } = bundler.bundle();
+    result.code        = code;
+    result.modules     = modules;
+    result.success     = true;
+  } catch (e) {
+    result.errors.push({ message: e.message, name: e.name, file: e.file || null });
+  }
+
+  return result;
+}
+
+module.exports = { bundle, Bundler, BundleError };