@xnoxs/flux-lang 3.1.1 → 3.2.0

package/src/stdlib.js

@@ -6,17 +6,44 @@
 
 // ── 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
+  // Sequences
+  'range', 'zip', 'enumerate', 'flatten', 'chunk', 'unique', 'groupBy', 'sortBy',
+
+  // Array pipe helpers
   'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex',
   'some', 'every', 'join', 'sort', 'flat', 'flatMap', 'includes',
+
+  // Array extras
+  'first', 'last', 'take', 'drop', 'takeWhile', 'dropWhile',
+  'compact', 'intersection', 'difference', 'arrayUnion', 'unzip',
+  'countBy', 'minBy', 'maxBy', 'toPairs', 'partition',
+  'count', 'head', 'tail', 'nth', 'rotate', 'sliding',
+
+  // Math
+  'clamp', 'sum', 'product',
+  'min', 'max', 'abs', 'floor', 'ceil', 'round',
+  'mean', 'median', 'stdDev', 'lerp',
+  'randInt', 'sample', 'shuffle',
+
+  // Objects
+  'pick', 'omit', 'deepEqual', 'deepClone',
+  'mapValues', 'filterValues', 'fromEntries',
+  'keys', 'values', 'entries', 'merge', 'invert', 'defaults',
+
+  // Strings
+  'capitalize', 'camelCase', 'snakeCase', 'kebabCase', 'truncate', 'pad',
+  'padStart', 'padEnd', 'trim', 'trimStart', 'trimEnd',
+  'words', 'lines', 'startsWith', 'endsWith', 'repeat', 'replaceAll', 'reverseStr',
+
+  // Type checks
+  'isNil', 'isString', 'isNumber', 'isArray', 'isObject', 'isFunction', 'isBool',
+
+  // Async
+  'sleep', 'retry', 'memoize', 'timeout', 'debounce', 'throttle', 'allSettled',
+
+  // Functional
+  'pipe', 'compose', 'partial', 'curry',
+  'identity', 'noop', 'once', 'flip', 'complement',
 ];
 
 /**
@@ -35,7 +62,6 @@ function buildStdlib(symbols) {
   const parts = ['// ── Flux stdlib ──'];
 
   // ── Array pipe helpers ─────────────────────────────────────────────────────
-  // Standalone wrappers so |> map(...) / |> filter(...) etc. work correctly.
 
   if (needed.has('map')) {
     parts.push(`
@@ -180,6 +206,171 @@ function sortBy(arr, fn) {
 }`);
   }
 
+  // ── Array extras ───────────────────────────────────────────────────────────
+
+  if (needed.has('first') || needed.has('head')) {
+    parts.push(`
+function first(arr) { return arr[0]; }
+function head(arr) { return arr[0]; }`);
+  }
+
+  if (needed.has('last')) {
+    parts.push(`
+function last(arr) { return arr[arr.length - 1]; }`);
+  }
+
+  if (needed.has('tail')) {
+    parts.push(`
+function tail(arr) { return arr.slice(1); }`);
+  }
+
+  if (needed.has('nth')) {
+    parts.push(`
+function nth(arr, n) { return n < 0 ? arr[arr.length + n] : arr[n]; }`);
+  }
+
+  if (needed.has('take')) {
+    parts.push(`
+function take(arr, n) { return arr.slice(0, n); }`);
+  }
+
+  if (needed.has('drop')) {
+    parts.push(`
+function drop(arr, n) { return arr.slice(n); }`);
+  }
+
+  if (needed.has('takeWhile')) {
+    parts.push(`
+function takeWhile(arr, fn) {
+  var i = 0;
+  while (i < arr.length && fn(arr[i])) i++;
+  return arr.slice(0, i);
+}`);
+  }
+
+  if (needed.has('dropWhile')) {
+    parts.push(`
+function dropWhile(arr, fn) {
+  var i = 0;
+  while (i < arr.length && fn(arr[i])) i++;
+  return arr.slice(i);
+}`);
+  }
+
+  if (needed.has('compact')) {
+    parts.push(`
+function compact(arr) {
+  return arr.filter(function(v) { return v != null && v !== false && v !== 0 && v !== ''; });
+}`);
+  }
+
+  if (needed.has('intersection')) {
+    parts.push(`
+function intersection(a, b) {
+  var s = new Set(b);
+  return a.filter(function(v) { return s.has(v); });
+}`);
+  }
+
+  if (needed.has('difference')) {
+    parts.push(`
+function difference(a, b) {
+  var s = new Set(b);
+  return a.filter(function(v) { return !s.has(v); });
+}`);
+  }
+
+  if (needed.has('arrayUnion')) {
+    parts.push(`
+function arrayUnion(a, b) {
+  return Array.from(new Set(a.concat(b)));
+}`);
+  }
+
+  if (needed.has('unzip')) {
+    parts.push(`
+function unzip(pairs) {
+  var a = [], b = [];
+  for (var i = 0; i < pairs.length; i++) { a.push(pairs[i][0]); b.push(pairs[i][1]); }
+  return [a, b];
+}`);
+  }
+
+  if (needed.has('countBy')) {
+    parts.push(`
+function countBy(arr, fn) {
+  return arr.reduce(function(acc, v) {
+    var k = typeof fn === 'function' ? fn(v) : v[fn];
+    acc[k] = (acc[k] || 0) + 1;
+    return acc;
+  }, {});
+}`);
+  }
+
+  if (needed.has('minBy')) {
+    parts.push(`
+function minBy(arr, fn) {
+  if (!arr.length) return undefined;
+  return arr.reduce(function(best, v) {
+    return (typeof fn === 'function' ? fn(v) : v[fn]) < (typeof fn === 'function' ? fn(best) : best[fn]) ? v : best;
+  });
+}`);
+  }
+
+  if (needed.has('maxBy')) {
+    parts.push(`
+function maxBy(arr, fn) {
+  if (!arr.length) return undefined;
+  return arr.reduce(function(best, v) {
+    return (typeof fn === 'function' ? fn(v) : v[fn]) > (typeof fn === 'function' ? fn(best) : best[fn]) ? v : best;
+  });
+}`);
+  }
+
+  if (needed.has('toPairs')) {
+    parts.push(`
+function toPairs(obj) {
+  return Object.keys(obj).map(function(k) { return [k, obj[k]]; });
+}`);
+  }
+
+  if (needed.has('partition')) {
+    parts.push(`
+function partition(arr, fn) {
+  var yes = [], no = [];
+  arr.forEach(function(v) { (fn(v) ? yes : no).push(v); });
+  return [yes, no];
+}`);
+  }
+
+  if (needed.has('count')) {
+    parts.push(`
+function count(arr, fn) {
+  if (typeof fn !== 'function') return arr.length;
+  return arr.reduce(function(n, v) { return fn(v) ? n + 1 : n; }, 0);
+}`);
+  }
+
+  if (needed.has('rotate')) {
+    parts.push(`
+function rotate(arr, n) {
+  var len = arr.length;
+  if (!len) return [];
+  var k = ((n % len) + len) % len;
+  return arr.slice(k).concat(arr.slice(0, k));
+}`);
+  }
+
+  if (needed.has('sliding')) {
+    parts.push(`
+function sliding(arr, size, step) {
+  step = step || 1;
+  var out = [];
+  for (var i = 0; i + size <= arr.length; i += step) out.push(arr.slice(i, i + size));
+  return out;
+}`);
+  }
+
   // ── Math ───────────────────────────────────────────────────────────────────
 
   if (needed.has('clamp')) {
@@ -203,6 +394,79 @@ function product(arr) {
 }`);
   }
 
+  if (needed.has('min')) {
+    parts.push(`
+function min(arr) {
+  if (arguments.length > 1) return Math.min.apply(null, arguments);
+  return Math.min.apply(null, arr);
+}`);
+  }
+
+  if (needed.has('max')) {
+    parts.push(`
+function max(arr) {
+  if (arguments.length > 1) return Math.max.apply(null, arguments);
+  return Math.max.apply(null, arr);
+}`);
+  }
+
+  if (needed.has('abs')) {
+    parts.push(`
+function abs(n) { return Math.abs(n); }`);
+  }
+
+  if (needed.has('floor')) {
+    parts.push(`
+function floor(n) { return Math.floor(n); }`);
+  }
+
+  if (needed.has('ceil')) {
+    parts.push(`
+function ceil(n) { return Math.ceil(n); }`);
+  }
+
+  if (needed.has('round')) {
+    parts.push(`
+function round(n, decimals) {
+  if (decimals == null) return Math.round(n);
+  var f = Math.pow(10, decimals);
+  return Math.round(n * f) / f;
+}`);
+  }
+
+  if (needed.has('mean')) {
+    parts.push(`
+function mean(arr) {
+  if (!arr.length) return 0;
+  return arr.reduce(function(a, b) { return a + b; }, 0) / arr.length;
+}`);
+  }
+
+  if (needed.has('median')) {
+    parts.push(`
+function median(arr) {
+  if (!arr.length) return 0;
+  var s = arr.slice().sort(function(a, b) { return a - b; });
+  var m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}`);
+  }
+
+  if (needed.has('stdDev')) {
+    parts.push(`
+function stdDev(arr) {
+  if (!arr.length) return 0;
+  var m = arr.reduce(function(a, b) { return a + b; }, 0) / arr.length;
+  var variance = arr.reduce(function(acc, v) { return acc + (v - m) * (v - m); }, 0) / arr.length;
+  return Math.sqrt(variance);
+}`);
+  }
+
+  if (needed.has('lerp')) {
+    parts.push(`
+function lerp(a, b, t) { return a + (b - a) * t; }`);
+  }
+
   if (needed.has('randInt')) {
     parts.push(`
 function randInt(min, max) {
@@ -275,6 +539,49 @@ function fromEntries(entries) {
 }`);
   }
 
+  if (needed.has('keys')) {
+    parts.push(`
+function keys(obj) { return Object.keys(obj); }`);
+  }
+
+  if (needed.has('values')) {
+    parts.push(`
+function values(obj) { return Object.values(obj); }`);
+  }
+
+  if (needed.has('entries')) {
+    parts.push(`
+function entries(obj) { return Object.entries(obj); }`);
+  }
+
+  if (needed.has('merge')) {
+    parts.push(`
+function merge() {
+  return Object.assign.apply(Object, [{}].concat(Array.from(arguments)));
+}`);
+  }
+
+  if (needed.has('invert')) {
+    parts.push(`
+function invert(obj) {
+  var out = {};
+  Object.keys(obj).forEach(function(k) { out[obj[k]] = k; });
+  return out;
+}`);
+  }
+
+  if (needed.has('defaults')) {
+    parts.push(`
+function defaults(obj) {
+  var sources = Array.from(arguments).slice(1);
+  var out = Object.assign({}, obj);
+  sources.forEach(function(s) {
+    Object.keys(s).forEach(function(k) { if (out[k] == null) out[k] = s[k]; });
+  });
+  return out;
+}`);
+  }
+
   if (needed.has('deepEqual')) {
     parts.push(`
 function deepEqual(a, b) {
@@ -289,6 +596,162 @@ function deepClone(v) {
 }`);
   }
 
+  // ── 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;
+  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);
+}`);
+  }
+
+  if (needed.has('padStart')) {
+    parts.push(`
+function padStart(s, len, char) {
+  return String(s).padStart(len, char || ' ');
+}`);
+  }
+
+  if (needed.has('padEnd')) {
+    parts.push(`
+function padEnd(s, len, char) {
+  return String(s).padEnd(len, char || ' ');
+}`);
+  }
+
+  if (needed.has('trim')) {
+    parts.push(`
+function trim(s) { return String(s).trim(); }`);
+  }
+
+  if (needed.has('trimStart')) {
+    parts.push(`
+function trimStart(s) { return String(s).trimStart(); }`);
+  }
+
+  if (needed.has('trimEnd')) {
+    parts.push(`
+function trimEnd(s) { return String(s).trimEnd(); }`);
+  }
+
+  if (needed.has('words')) {
+    parts.push(`
+function words(s) { return String(s).trim().split(/\\s+/); }`);
+  }
+
+  if (needed.has('lines')) {
+    parts.push(`
+function lines(s) { return String(s).split(/\\r?\\n/); }`);
+  }
+
+  if (needed.has('startsWith')) {
+    parts.push(`
+function startsWith(s, prefix) { return String(s).startsWith(prefix); }`);
+  }
+
+  if (needed.has('endsWith')) {
+    parts.push(`
+function endsWith(s, suffix) { return String(s).endsWith(suffix); }`);
+  }
+
+  if (needed.has('repeat')) {
+    parts.push(`
+function repeat(s, n) { return String(s).repeat(n); }`);
+  }
+
+  if (needed.has('replaceAll')) {
+    parts.push(`
+function replaceAll(s, search, replacement) {
+  return String(s).split(search).join(replacement);
+}`);
+  }
+
+  if (needed.has('reverseStr')) {
+    parts.push(`
+function reverseStr(s) { return String(s).split('').reverse().join(''); }`);
+  }
+
+  // ── Type checks ────────────────────────────────────────────────────────────
+
+  if (needed.has('isNil')) {
+    parts.push(`
+function isNil(v) { return v == null; }`);
+  }
+
+  if (needed.has('isString')) {
+    parts.push(`
+function isString(v) { return typeof v === 'string'; }`);
+  }
+
+  if (needed.has('isNumber')) {
+    parts.push(`
+function isNumber(v) { return typeof v === 'number' && !isNaN(v); }`);
+  }
+
+  if (needed.has('isArray')) {
+    parts.push(`
+function isArray(v) { return Array.isArray(v); }`);
+  }
+
+  if (needed.has('isObject')) {
+    parts.push(`
+function isObject(v) { return v !== null && typeof v === 'object' && !Array.isArray(v); }`);
+  }
+
+  if (needed.has('isFunction')) {
+    parts.push(`
+function isFunction(v) { return typeof v === 'function'; }`);
+  }
+
+  if (needed.has('isBool')) {
+    parts.push(`
+function isBool(v) { return typeof v === 'boolean'; }`);
+  }
+
   // ── Async ──────────────────────────────────────────────────────────────────
 
   if (needed.has('sleep')) {
@@ -306,12 +769,55 @@ async function retry(fn, attempts, delay) {
   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));
+      await new Promise(function(r) { setTimeout(r, delay * Math.pow(2, i)); });
     }
   }
 }`);
   }
 
+  if (needed.has('timeout')) {
+    parts.push(`
+function timeout(fn, ms) {
+  return Promise.race([
+    typeof fn === 'function' ? fn() : fn,
+    new Promise(function(_, reject) {
+      setTimeout(function() { reject(new Error('Timeout after ' + ms + 'ms')); }, ms);
+    })
+  ]);
+}`);
+  }
+
+  if (needed.has('allSettled')) {
+    parts.push(`
+function allSettled(promises) {
+  return Promise.allSettled(promises);
+}`);
+  }
+
+  if (needed.has('debounce')) {
+    parts.push(`
+function debounce(fn, ms) {
+  var timer;
+  return function() {
+    clearTimeout(timer);
+    var args = arguments;
+    var ctx  = this;
+    timer = setTimeout(function() { fn.apply(ctx, args); }, ms);
+  };
+}`);
+  }
+
+  if (needed.has('throttle')) {
+    parts.push(`
+function throttle(fn, ms) {
+  var last = 0;
+  return function() {
+    var now = Date.now();
+    if (now - last >= ms) { last = now; return fn.apply(this, arguments); }
+  };
+}`);
+  }
+
   if (needed.has('memoize')) {
     parts.push(`
 function memoize(fn) {
@@ -363,57 +869,41 @@ function curry(fn) {
 }`);
   }
 
-  // ── Strings ────────────────────────────────────────────────────────────────
-
-  if (needed.has('capitalize')) {
+  if (needed.has('identity')) {
     parts.push(`
-function capitalize(s) {
-  return s ? s[0].toUpperCase() + s.slice(1) : s;
-}`);
+function identity(v) { return v; }`);
   }
 
-  if (needed.has('camelCase')) {
+  if (needed.has('noop')) {
     parts.push(`
-function camelCase(s) {
-  return s.replace(/[-_\\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });
-}`);
+function noop() {}`);
   }
 
-  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')) {
+  if (needed.has('once')) {
     parts.push(`
-function kebabCase(s) {
-  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\\s]+/g, '-').replace(/^-/, '');
+function once(fn) {
+  var called = false, result;
+  return function() {
+    if (!called) { called = true; result = fn.apply(this, arguments); }
+    return result;
+  };
 }`);
   }
 
-  if (needed.has('truncate')) {
+  if (needed.has('flip')) {
     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;
+function flip(fn) {
+  return function() {
+    var args = Array.from(arguments);
+    return fn.apply(this, [args[1], args[0]].concat(args.slice(2)));
+  };
 }`);
   }
 
-  if (needed.has('pad')) {
+  if (needed.has('complement')) {
     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);
+function complement(fn) {
+  return function() { return !fn.apply(this, arguments); };
 }`);
   }