@xnoxs/flux-lang 3.1.1

package/src/sourcemap.js

@@ -0,0 +1,82 @@
+'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/stdlib.js

@@ -0,0 +1,436 @@
+'use strict';
+
+// ── Flux Standard Library ─────────────────────────────────────────────────────
+// Runtime helpers injected into compiled Flux programs.
+// Each function is self-contained so tree-shaking can work later.
+
+// ── Detection: which stdlib symbols appear in compiled JS? ───────────────────
+const STDLIB_SYMBOLS = [
+  'range', 'zip', 'enumerate', 'clamp', 'sum', 'product',
+  'flatten', 'chunk', 'unique', 'groupBy', 'sortBy',
+  'pick', 'omit', 'deepEqual', 'deepClone',
+  'sleep', 'retry', 'memoize',
+  'pipe', 'compose', 'partial', 'curry',
+  'capitalize', 'camelCase', 'snakeCase', 'kebabCase', 'truncate', 'pad',
+  'randInt', 'sample', 'shuffle',
+  'mapValues', 'filterValues', 'fromEntries',
+  // Array pipe helpers — standalone wrappers around Array.prototype methods
+  'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex',
+  'some', 'every', 'join', 'sort', 'flat', 'flatMap', 'includes',
+];
+
+/**
+ * Build the stdlib preamble JavaScript string.
+ * If `symbols` is provided, only include helpers that are used.
+ * @param {string[]} [symbols]  - list of stdlib names actually used in the output
+ * @returns {string}
+ */
+function buildStdlib(symbols) {
+  const needed = symbols
+    ? new Set(symbols.filter(s => STDLIB_SYMBOLS.includes(s)))
+    : new Set(STDLIB_SYMBOLS);
+
+  if (needed.size === 0) return '';
+
+  const parts = ['// ── Flux stdlib ──'];
+
+  // ── Array pipe helpers ─────────────────────────────────────────────────────
+  // Standalone wrappers so |> map(...) / |> filter(...) etc. work correctly.
+
+  if (needed.has('map')) {
+    parts.push(`
+function map(arr, fn) { return arr.map(fn); }`);
+  }
+
+  if (needed.has('filter')) {
+    parts.push(`
+function filter(arr, fn) { return arr.filter(fn); }`);
+  }
+
+  if (needed.has('reduce')) {
+    parts.push(`
+function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }`);
+  }
+
+  if (needed.has('forEach')) {
+    parts.push(`
+function forEach(arr, fn) { arr.forEach(fn); return arr; }`);
+  }
+
+  if (needed.has('find')) {
+    parts.push(`
+function find(arr, fn) { return arr.find(fn); }`);
+  }
+
+  if (needed.has('findIndex')) {
+    parts.push(`
+function findIndex(arr, fn) { return arr.findIndex(fn); }`);
+  }
+
+  if (needed.has('some')) {
+    parts.push(`
+function some(arr, fn) { return arr.some(fn); }`);
+  }
+
+  if (needed.has('every')) {
+    parts.push(`
+function every(arr, fn) { return arr.every(fn); }`);
+  }
+
+  if (needed.has('join')) {
+    parts.push(`
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }`);
+  }
+
+  if (needed.has('sort')) {
+    parts.push(`
+function sort(arr, fn) { return arr.slice().sort(fn); }`);
+  }
+
+  if (needed.has('flat')) {
+    parts.push(`
+function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }`);
+  }
+
+  if (needed.has('flatMap')) {
+    parts.push(`
+function flatMap(arr, fn) { return arr.flatMap(fn); }`);
+  }
+
+  if (needed.has('includes')) {
+    parts.push(`
+function includes(arr, val) { return arr.includes(val); }`);
+  }
+
+  // ── Sequences ──────────────────────────────────────────────────────────────
+
+  if (needed.has('range')) {
+    parts.push(`
+function range(start, end, step) {
+  if (arguments.length === 1) { end = start; start = 0; }
+  step = step || (end >= start ? 1 : -1);
+  const out = [];
+  if (step > 0) { for (let i = start; i < end; i += step) out.push(i); }
+  else          { for (let i = start; i > end; i += step) out.push(i); }
+  return out;
+}`);
+  }
+
+  if (needed.has('zip')) {
+    parts.push(`
+function zip() {
+  const arrays = Array.from(arguments);
+  const len = Math.min.apply(null, arrays.map(function(a) { return a.length; }));
+  const out = [];
+  for (let i = 0; i < len; i++) out.push(arrays.map(function(a) { return a[i]; }));
+  return out;
+}`);
+  }
+
+  if (needed.has('enumerate')) {
+    parts.push(`
+function enumerate(arr, start) {
+  start = start || 0;
+  return arr.map(function(v, i) { return [i + start, v]; });
+}`);
+  }
+
+  if (needed.has('flatten')) {
+    parts.push(`
+function flatten(arr, depth) {
+  return depth == null ? arr.flat(Infinity) : arr.flat(depth);
+}`);
+  }
+
+  if (needed.has('chunk')) {
+    parts.push(`
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}`);
+  }
+
+  if (needed.has('unique')) {
+    parts.push(`
+function unique(arr) {
+  return Array.from(new Set(arr));
+}`);
+  }
+
+  if (needed.has('groupBy')) {
+    parts.push(`
+function groupBy(arr, fn) {
+  return arr.reduce(function(acc, v) {
+    var k = typeof fn === 'function' ? fn(v) : v[fn];
+    (acc[k] = acc[k] || []).push(v);
+    return acc;
+  }, {});
+}`);
+  }
+
+  if (needed.has('sortBy')) {
+    parts.push(`
+function sortBy(arr, fn) {
+  return arr.slice().sort(function(a, b) {
+    var ka = typeof fn === 'function' ? fn(a) : a[fn];
+    var kb = typeof fn === 'function' ? fn(b) : b[fn];
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+}`);
+  }
+
+  // ── Math ───────────────────────────────────────────────────────────────────
+
+  if (needed.has('clamp')) {
+    parts.push(`
+function clamp(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}`);
+  }
+
+  if (needed.has('sum')) {
+    parts.push(`
+function sum(arr) {
+  return arr.reduce(function(a, b) { return a + b; }, 0);
+}`);
+  }
+
+  if (needed.has('product')) {
+    parts.push(`
+function product(arr) {
+  return arr.reduce(function(a, b) { return a * b; }, 1);
+}`);
+  }
+
+  if (needed.has('randInt')) {
+    parts.push(`
+function randInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}`);
+  }
+
+  if (needed.has('sample')) {
+    parts.push(`
+function sample(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}`);
+  }
+
+  if (needed.has('shuffle')) {
+    parts.push(`
+function shuffle(arr) {
+  var a = arr.slice();
+  for (var i = a.length - 1; i > 0; i--) {
+    var j = Math.floor(Math.random() * (i + 1));
+    var tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+  }
+  return a;
+}`);
+  }
+
+  // ── Objects ────────────────────────────────────────────────────────────────
+
+  if (needed.has('pick')) {
+    parts.push(`
+function pick(obj, keys) {
+  var out = {};
+  keys.forEach(function(k) { if (Object.prototype.hasOwnProperty.call(obj, k)) out[k] = obj[k]; });
+  return out;
+}`);
+  }
+
+  if (needed.has('omit')) {
+    parts.push(`
+function omit(obj, keys) {
+  var ks = new Set(keys);
+  var out = {};
+  Object.keys(obj).forEach(function(k) { if (!ks.has(k)) out[k] = obj[k]; });
+  return out;
+}`);
+  }
+
+  if (needed.has('mapValues')) {
+    parts.push(`
+function mapValues(obj, fn) {
+  var out = {};
+  Object.keys(obj).forEach(function(k) { out[k] = fn(obj[k], k); });
+  return out;
+}`);
+  }
+
+  if (needed.has('filterValues')) {
+    parts.push(`
+function filterValues(obj, fn) {
+  var out = {};
+  Object.keys(obj).forEach(function(k) { if (fn(obj[k], k)) out[k] = obj[k]; });
+  return out;
+}`);
+  }
+
+  if (needed.has('fromEntries')) {
+    parts.push(`
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}`);
+  }
+
+  if (needed.has('deepEqual')) {
+    parts.push(`
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}`);
+  }
+
+  if (needed.has('deepClone')) {
+    parts.push(`
+function deepClone(v) {
+  return JSON.parse(JSON.stringify(v));
+}`);
+  }
+
+  // ── Async ──────────────────────────────────────────────────────────────────
+
+  if (needed.has('sleep')) {
+    parts.push(`
+function sleep(ms) {
+  return new Promise(function(resolve) { setTimeout(resolve, ms); });
+}`);
+  }
+
+  if (needed.has('retry')) {
+    parts.push(`
+async function retry(fn, attempts, delay) {
+  attempts = attempts || 3;
+  delay    = delay    || 300;
+  for (var i = 0; i < attempts; i++) {
+    try { return await fn(); } catch(e) {
+      if (i === attempts - 1) throw e;
+      await sleep(delay * Math.pow(2, i));
+    }
+  }
+}`);
+  }
+
+  if (needed.has('memoize')) {
+    parts.push(`
+function memoize(fn) {
+  var cache = new Map();
+  return function() {
+    var key = JSON.stringify(arguments);
+    if (cache.has(key)) return cache.get(key);
+    var result = fn.apply(this, arguments);
+    cache.set(key, result);
+    return result;
+  };
+}`);
+  }
+
+  // ── Functional ─────────────────────────────────────────────────────────────
+
+  if (needed.has('pipe')) {
+    parts.push(`
+function pipe() {
+  var fns = Array.from(arguments);
+  return function(x) { return fns.reduce(function(v, f) { return f(v); }, x); };
+}`);
+  }
+
+  if (needed.has('compose')) {
+    parts.push(`
+function compose() {
+  var fns = Array.from(arguments);
+  return function(x) { return fns.reduceRight(function(v, f) { return f(v); }, x); };
+}`);
+  }
+
+  if (needed.has('partial')) {
+    parts.push(`
+function partial(fn) {
+  var args = Array.from(arguments).slice(1);
+  return function() { return fn.apply(this, args.concat(Array.from(arguments))); };
+}`);
+  }
+
+  if (needed.has('curry')) {
+    parts.push(`
+function curry(fn) {
+  return function curried() {
+    var args = Array.from(arguments);
+    if (args.length >= fn.length) return fn.apply(this, args);
+    return function() { return curried.apply(this, args.concat(Array.from(arguments))); };
+  };
+}`);
+  }
+
+  // ── Strings ────────────────────────────────────────────────────────────────
+
+  if (needed.has('capitalize')) {
+    parts.push(`
+function capitalize(s) {
+  return s ? s[0].toUpperCase() + s.slice(1) : s;
+}`);
+  }
+
+  if (needed.has('camelCase')) {
+    parts.push(`
+function camelCase(s) {
+  return s.replace(/[-_\\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });
+}`);
+  }
+
+  if (needed.has('snakeCase')) {
+    parts.push(`
+function snakeCase(s) {
+  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\\s]+/g, '_').replace(/^_/, '');
+}`);
+  }
+
+  if (needed.has('kebabCase')) {
+    parts.push(`
+function kebabCase(s) {
+  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\\s]+/g, '-').replace(/^-/, '');
+}`);
+  }
+
+  if (needed.has('truncate')) {
+    parts.push(`
+function truncate(s, len, suffix) {
+  suffix = suffix != null ? suffix : '...';
+  if (s.length <= len) return s;
+  // FIX: guard against suffix longer than len to avoid negative slice index
+  var cut = len - suffix.length;
+  if (cut <= 0) return suffix.slice(0, len);
+  return s.slice(0, cut) + suffix;
+}`);
+  }
+
+  if (needed.has('pad')) {
+    parts.push(`
+function pad(s, len, char) {
+  char = char || ' ';
+  s = String(s);
+  var total = len - s.length;
+  if (total <= 0) return s;
+  var half = Math.floor(total / 2);
+  return char.repeat(half) + s + char.repeat(total - half);
+}`);
+  }
+
+  parts.push('// ── end stdlib ──\n');
+  return parts.join('\n');
+}
+
+/**
+ * Detect which stdlib symbols are referenced in a JS string.
+ * @param {string} jsCode
+ * @returns {string[]}
+ */
+function detectUsedSymbols(jsCode) {
+  return STDLIB_SYMBOLS.filter(sym => {
+    const re = new RegExp(`\\b${sym}\\s*\\(`, 'g');
+    return re.test(jsCode);
+  });
+}
+
+module.exports = { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS };