@lnsy/data-table 0.1.0

package/src/formula.js

@@ -0,0 +1,632 @@
+/**
+ * Formula Engine
+ *
+ * A small, dependency-free formula parser and evaluator for grid data.
+ *
+ * Supported syntax:
+ *   - Numbers, quoted strings, booleans (TRUE/FALSE)
+ *   - Cell references:  A1, $B$2
+ *   - Ranges:           A1:B10 (only valid inside functions)
+ *   - Operators:        + - * / ^ % & (concat) = <> < > <= >=
+ *   - Parentheses, unary minus
+ *   - Function calls:   SUM(A1:A5), IF(A1>2, "yes", "no"), ...
+ *
+ * Endpoint access from calculations:
+ *   =HTTP("https://…")                 → response body as text
+ *   =HTTP("https://….json", "a.b.0")   → JSON body, path-extracted value
+ *   =ENDPOINT("name")                  → fetches a named endpoint registered on
+ *                                        the component via `setEndpoints()`
+ *
+ * Evaluation is asynchronous because endpoint calls hit the network.
+ * Results are cached (with a TTL) so recalcs don't hammer endpoints.
+ */
+
+// ---------------------------------------------------------------------------
+// Tokenizer
+// ---------------------------------------------------------------------------
+
+const TOKEN_RE = new RegExp(
+  [
+    '\\s+',                                    // whitespace (skipped)
+    '\\d+\\.?\\d*(?:[eE][+-]?\\d+)?',          // number
+    '"(?:[^"]|"")*"',                       // string ("" escapes ")
+    '\\$?[A-Za-z]+\\$?\\d+\\s*:\\s*\\$?[A-Za-z]+\\$?\\d+', // range
+    '\\$?[A-Za-z]+\\$?\\d+',                   // cell ref
+    '[A-Za-z_][A-Za-z0-9_.]*',                 // identifier / function name
+    '<>|<=|>=|[-+*/^%&=<>(),:]',               // operators & punctuation
+  ].join('|'),
+  'y'
+);
+
+function tokenize(input) {
+  const tokens = [];
+  let pos = 0;
+  while (pos < input.length) {
+    TOKEN_RE.lastIndex = pos;
+    const match = TOKEN_RE.exec(input);
+    if (!match) {
+      throw new Error(`Unexpected character at ${pos}: "${input[pos]}"`);
+    }
+    const text = match[0];
+    if (!/^\s+$/.test(text)) {
+      tokens.push({ text, pos });
+    }
+    pos += text.length;
+  }
+  return tokens;
+}
+
+// ---------------------------------------------------------------------------
+// Parser — produces an AST of nested arrays/objects
+// ---------------------------------------------------------------------------
+
+function parse(tokens) {
+  let i = 0;
+
+  const peek = () => tokens[i];
+  const next = () => tokens[i++];
+  const expect = (text) => {
+    const t = next();
+    if (!t || t.text !== text) {
+      throw new Error(`Expected "${text}"${t ? ` but found "${t.text}"` : ''}`);
+    }
+    return t;
+  };
+
+  function parseExpression() { return parseComparison(); }
+
+  function parseComparison() {
+    let left = parseConcat();
+    while (peek() && ['=', '<>', '<', '>', '<=', '>='].includes(peek().text)) {
+      const op = next().text;
+      const right = parseConcat();
+      left = { type: 'binary', op, left, right };
+    }
+    return left;
+  }
+
+  function parseConcat() {
+    let left = parseAdditive();
+    while (peek() && peek().text === '&') {
+      next();
+      const right = parseAdditive();
+      left = { type: 'binary', op: '&', left, right };
+    }
+    return left;
+  }
+
+  function parseAdditive() {
+    let left = parseMultiplicative();
+    while (peek() && (peek().text === '+' || peek().text === '-')) {
+      const op = next().text;
+      const right = parseMultiplicative();
+      left = { type: 'binary', op, left, right };
+    }
+    return left;
+  }
+
+  function parseMultiplicative() {
+    let left = parseUnary();
+    while (peek() && ['*', '/', '%'].includes(peek().text)) {
+      const op = next().text;
+      const right = parseUnary();
+      left = { type: 'binary', op, left, right };
+    }
+    return left;
+  }
+
+  function parseUnary() {
+    if (peek() && peek().text === '-') {
+      next();
+      return { type: 'negate', value: parseUnary() };
+    }
+    if (peek() && peek().text === '+') {
+      next();
+      return parseUnary();
+    }
+    return parsePower();
+  }
+
+  function parsePower() {
+    const base = parsePrimary();
+    if (peek() && peek().text === '^') {
+      next();
+      const exponent = parseUnary(); // right associative
+      return { type: 'binary', op: '^', left: base, right: exponent };
+    }
+    return base;
+  }
+
+  function parsePrimary() {
+    const token = next();
+    if (!token) throw new Error('Unexpected end of formula');
+
+    const text = token.text;
+
+    if (text === '(') {
+      const expr = parseExpression();
+      expect(')');
+      return expr;
+    }
+
+    if (/^\d/.test(text)) {
+      return { type: 'number', value: parseFloat(text) };
+    }
+
+    if (text.startsWith('"')) {
+      return { type: 'string', value: text.slice(1, -1).replace(/""/g, '"') };
+    }
+
+    // Range reference like "$A$1:$B$5" (single token)
+    if (text.includes(':')) {
+      const [a, b] = text.split(':').map((s) => s.trim());
+      return { type: 'range', start: parseRefToken(a), end: parseRefToken(b) };
+    }
+
+    // Cell reference like "A1" / "$B$2", possibly followed by ":C3"
+    if (/^\$?[A-Za-z]+\$?\d+$/.test(text)) {
+      const start = parseRefToken(text);
+      if (peek() && peek().text === ':') {
+        next();
+        const t2 = next();
+        if (!t2) throw new Error('Expected cell after ":"');
+        return { type: 'range', start, end: parseRefToken(t2.text) };
+      }
+      return { type: 'ref', ...start };
+    }
+
+    // Function call or bare identifier
+    if (/^[A-Za-z_]/.test(text)) {
+      if (peek() && peek().text === '(') {
+        next(); // consume (
+        const args = [];
+        if (peek() && peek().text === ')') {
+          next();
+        } else {
+          for (;;) {
+            args.push(parseExpression());
+            if (peek() && peek().text === ',') {
+              next();
+            } else {
+              break;
+            }
+          }
+          expect(')');
+        }
+        return { type: 'call', name: normalizeName(text), args };
+      }
+      // Bare identifier: TRUE/FALSE only
+      const upper = text.toUpperCase();
+      if (upper === 'TRUE') return { type: 'boolean', value: true };
+      if (upper === 'FALSE') return { type: 'boolean', value: false };
+      throw new Error(`Unknown identifier "${text}"`);
+    }
+
+    throw new Error(`Unexpected token "${text}"`);
+  }
+
+  const result = parseExpression();
+  if (i !== tokens.length) {
+    throw new Error(`Unexpected token "${tokens[i].text}" after expression`);
+  }
+  return result;
+}
+
+function normalizeName(name) {
+  return name.toUpperCase();
+}
+
+function parseRefToken(text) {
+  const cleaned = text.replace(/\$/g, '');
+  const m = cleaned.match(/^([A-Za-z]+)(\d+)$/);
+  if (!m) throw new Error(`Invalid cell reference "${text}"`);
+  return { col: colToIndex(m[1]), row: parseInt(m[2], 10) - 1 };
+}
+
+export function colToIndex(letters) {
+  let n = 0;
+  for (const ch of letters.toUpperCase()) {
+    n = n * 26 + (ch.charCodeAt(0) - 64);
+  }
+  return n - 1; // zero-based column index
+}
+
+export function indexToCol(index) {
+  let s = '';
+  let n = index;
+  while (n >= 0) {
+    s = String.fromCharCode((n % 26) + 65) + s;
+    n = Math.floor(n / 26) - 1;
+  }
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// Runtime helpers
+// ---------------------------------------------------------------------------
+
+function flattenValues(args) {
+  const out = [];
+  for (const arg of args) {
+    if (Array.isArray(arg)) {
+      out.push(...flattenValues(arg));
+    } else {
+      out.push(arg);
+    }
+  }
+  return out;
+}
+
+function toNumber(value) {
+  if (value === null || value === undefined || value === '') return 0;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'boolean') return value ? 1 : 0;
+  const n = parseFloat(String(value).replace(/[$,%]/g, ''));
+  if (Number.isNaN(n)) throw new Error(`"${value}" is not a number`);
+  return n;
+}
+
+/** True when the value can be read as a number (COUNT skips everything else). */
+function isNumeric(value) {
+  if (typeof value === 'number') return Number.isFinite(value);
+  if (typeof value !== 'string' || value.trim() === '') return false;
+  return !Number.isNaN(parseFloat(value.replace(/[$,%]/g, '')));
+}
+
+function compare(a, b) {
+  const na = typeof a === 'number' ? a : parseFloat(a);
+  const nb = typeof b === 'number' ? b : parseFloat(b);
+  if (!Number.isNaN(na) && !Number.isNaN(nb) &&
+      a !== '' && b !== '' && String(a).trim() !== '' && String(b).trim() !== '') {
+    return na - nb;
+  }
+  const sa = String(a ?? '').toLowerCase();
+  const sb = String(b ?? '').toLowerCase();
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+
+/** Extract a dotted path ("a.b.0.c") from parsed JSON. */
+function extractJsonPath(data, path) {
+  if (!path) return data;
+  let current = data;
+  for (const part of path.split('.')) {
+    if (current === null || current === undefined) return '';
+    current = Array.isArray(current) ? current[parseInt(part, 10)] : current[part];
+  }
+  return current ?? '';
+}
+
+// ---------------------------------------------------------------------------
+// The engine
+// ---------------------------------------------------------------------------
+
+export class FormulaEngine {
+  /**
+   * @param {() => (string|number)[][]} getData  raw grid contents
+   */
+  constructor(getData) {
+    this.getData = getData;
+    /** computed values keyed "r:c" */
+    this.values = new Map();
+    /** formulas keyed "r:c" */
+    this.formulas = new Map();
+    /** named endpoints, e.g. { rates: "https://…" } */
+    this.endpoints = {};
+    /** ms to cache HTTP results */
+    this.httpCacheTTL = 30_000;
+    this._httpCache = new Map(); // url -> { time, promise/value }
+  }
+
+  setEndpoints(endpoints) {
+    this.endpoints = endpoints || {};
+    this.clearHttpCache();
+  }
+
+  clearHttpCache() {
+    this._httpCache.clear();
+  }
+
+  getRaw(row, col) {
+    const data = this.getData();
+    const value = data[row]?.[col];
+    return value === undefined || value === null ? '' : value;
+  }
+
+  /** Recompute every formula cell. Returns a map "r:c" → error string. */
+  async recalcAll() {
+    const data = this.getData();
+    this.values.clear();
+    this.formulas.clear();
+
+    for (let r = 0; r < data.length; r++) {
+      const row = data[r] || [];
+      for (let c = 0; c < row.length; c++) {
+        const raw = row[c];
+        if (typeof raw === 'string' && raw.startsWith('=')) {
+          this.formulas.set(`${r}:${c}`, raw.slice(1));
+        }
+      }
+    }
+
+    const errors = new Map();
+    for (const key of this.formulas.keys()) {
+      try {
+        await this.evaluateKey(key, new Set());
+      } catch (err) {
+        errors.set(key, err.message);
+        this.values.set(key, `#ERROR!`);
+      }
+    }
+    return errors;
+  }
+
+  async evaluateKey(key, visiting) {
+    if (this.values.has(key)) return this.values.get(key);
+    if (visiting.has(key)) throw new Error('#CIRCULAR!');
+    visiting.add(key);
+
+    const formula = this.formulas.get(key);
+    if (formula === undefined) {
+      const [r, c] = key.split(':').map(Number);
+      const raw = this.getRaw(r, c);
+      const value = raw === '' ? '' : coerceRaw(raw);
+      this.values.set(key, value);
+      return value;
+    }
+
+    let ast;
+    try {
+      ast = parse(tokenize(formula));
+    } catch (err) {
+      throw new Error(`#SYNTAX! (${err.message})`);
+    }
+
+    const value = await this.evalNode(ast, visiting);
+    this.values.set(key, value);
+    visiting.delete(key);
+    return value;
+  }
+
+  async evalNode(node, visiting) {
+    switch (node.type) {
+      case 'number':
+      case 'string':
+      case 'boolean':
+        return node.value;
+
+      case 'ref': {
+        const key = `${node.row}:${node.col}`;
+        if (this.formulas.has(key)) {
+          return this.evaluateKey(key, visiting);
+        }
+        const raw = this.getRaw(node.row, node.col);
+        return raw === '' ? '' : coerceRaw(raw);
+      }
+
+      case 'range': {
+        const out = [];
+        for (let r = node.start.row; r <= node.end.row; r++) {
+          const rowVals = [];
+          for (let c = node.start.col; c <= node.end.col; c++) {
+            const key = `${r}:${c}`;
+            if (this.formulas.has(key)) {
+              rowVals.push(await this.evaluateKey(key, visiting));
+            } else {
+              const raw = this.getRaw(r, c);
+              rowVals.push(raw === '' ? '' : coerceRaw(raw));
+            }
+          }
+          out.push(rowVals);
+        }
+        return out;
+      }
+
+      case 'negate':
+        return -toNumber(await this.evalNode(node.value, visiting));
+
+      case 'binary': {
+        const left = await this.evalNode(node.left, visiting);
+        const right = await this.evalNode(node.right, visiting);
+        return applyBinary(node.op, left, right);
+      }
+
+      case 'call':
+        return this.callFunction(node.name, node.args, visiting);
+
+      default:
+        throw new Error(`Unknown node type "${node.type}"`);
+    }
+  }
+
+  async callFunction(name, argNodes, visiting) {
+    // Short-circuiting functions evaluate lazily.
+    if (name === 'IF') {
+      if (argNodes.length < 2) throw new Error('IF requires 2–3 arguments');
+      const cond = await this.evalNode(argNodes[0], visiting);
+      if (truthy(cond)) return this.evalNode(argNodes[1], visiting);
+      return argNodes.length >= 3 ? this.evalNode(argNodes[2], visiting) : false;
+    }
+
+    if (name === 'IFERROR') {
+      try {
+        return await this.evalNode(argNodes[0], visiting);
+      } catch {
+        return argNodes.length >= 2 ? this.evalNode(argNodes[1], visiting) : '';
+      }
+    }
+
+    const args = [];
+    for (const arg of argNodes) {
+      args.push(await this.evalNode(arg, visiting));
+    }
+
+    const flat = () => flattenValues(args);
+    const nums = () => flat().filter((v) => v !== '' && v !== null && v !== undefined)
+      .map(toNumber);
+
+    switch (name) {
+      case 'SUM': return nums().reduce((a, b) => a + b, 0);
+      case 'AVERAGE':
+      case 'AVG': {
+        const list = nums();
+        return list.length ? list.reduce((a, b) => a + b, 0) / list.length : 0;
+      }
+      case 'MIN': {
+        const list = nums();
+        return list.length ? Math.min(...list) : 0;
+      }
+      case 'MAX': {
+        const list = nums();
+        return list.length ? Math.max(...list) : 0;
+      }
+      case 'COUNT': return flat().filter(isNumeric).length;
+      case 'COUNTA': return flat().filter((v) => v !== '' && v != null).length;
+      case 'ABS': return Math.abs(toNumber(args[0]));
+      case 'ROUND': {
+        const digits = args.length >= 2 ? toNumber(args[1]) : 0;
+        const factor = 10 ** digits;
+        return Math.round(toNumber(args[0]) * factor) / factor;
+      }
+      case 'FLOOR': return Math.floor(toNumber(args[0]));
+      case 'CEILING':
+      case 'CEIL': return Math.ceil(toNumber(args[0]));
+      case 'SQRT': return Math.sqrt(toNumber(args[0]));
+      case 'POWER':
+      case 'POW': return toNumber(args[0]) ** toNumber(args[1]);
+      case 'MOD': return toNumber(args[0]) % toNumber(args[1]);
+      case 'CONCAT':
+      case 'CONCATENATE':
+        return flat().map((v) => String(v ?? '')).join('');
+      case 'LEN': return String(args[0] ?? '').length;
+      case 'UPPER': return String(args[0] ?? '').toUpperCase();
+      case 'LOWER': return String(args[0] ?? '').toLowerCase();
+      case 'TRIM': return String(args[0] ?? '').trim();
+      case 'AND': return flat().every(truthy);
+      case 'OR': return flat().some(truthy);
+      case 'NOT': return !truthy(args[0]);
+      case 'TODAY': return new Date().toISOString().slice(0, 10);
+      case 'NOW': return new Date().toLocaleString();
+
+      /* ── Endpoint access ─────────────────────────────────── */
+
+      case 'HTTP': {
+        const url = String(args[0] ?? '').trim();
+        if (!url) return '';
+        const path = args.length >= 2 ? String(args[1]) : null;
+        const body = await this.fetchCached(url);
+        if (path === null) return typeof body === 'string'
+          ? body
+          : JSON.stringify(body);
+        return extractJsonPath(body, path);
+      }
+
+      case 'HTTPJSON': {
+        const url = String(args[0] ?? '').trim();
+        if (!url) return '';
+        const body = await this.fetchCached(url, true);
+        return extractJsonPath(body, args.length >= 2 ? String(args[1]) : null);
+      }
+
+      case 'ENDPOINT': {
+        const endpointName = String(args[0] ?? '').trim();
+        const url = this.endpoints[endpointName];
+        if (!url) throw new Error(`#NOENDPOINT! Unknown endpoint "${endpointName}"`);
+        const path = args.length >= 2 ? String(args[1]) : null;
+        const body = await this.fetchCached(url);
+        if (path === null) return typeof body === 'string'
+          ? body
+          : JSON.stringify(body);
+        return extractJsonPath(body, path);
+      }
+
+      default:
+        throw new Error(`#NAME? Unknown function "${name}"`);
+    }
+  }
+
+  /** Fetch with promise-deduplication and TTL caching. */
+  async fetchCached(url, forceJson = false) {
+    const cached = this._httpCache.get(url);
+    const now = Date.now();
+    if (cached && now - cached.time < this.httpCacheTTL) {
+      return cached.promise;
+    }
+
+    const promise = (async () => {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`#HTTP! ${response.status} ${response.statusText}`);
+      }
+      const contentType = response.headers.get('content-type') || '';
+      if (forceJson || contentType.includes('json')) {
+        return response.json();
+      }
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    })();
+
+    this._httpCache.set(url, { time: now, promise });
+    try {
+      return await promise;
+    } catch (err) {
+      // Don't cache failures for long.
+      this._httpCache.set(url, { time: now - this.httpCacheTTL + 3000, promise });
+      throw err;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Value coercion
+// ---------------------------------------------------------------------------
+
+function coerceRaw(raw) {
+  if (typeof raw !== 'string') return raw;
+  const trimmed = raw.trim();
+  if (trimmed === '') return raw;
+  if (/^-?\d+\.?\d*(?:[eE][+-]?\d+)?$/.test(trimmed)) return parseFloat(trimmed);
+  return raw;
+}
+
+function applyBinary(op, left, right) {
+  switch (op) {
+    case '+': return toNumber(left) + toNumber(right);
+    case '-': return toNumber(left) - toNumber(right);
+    case '*': return toNumber(left) * toNumber(right);
+    case '/': return toNumber(left) / toNumber(right);
+    case '%': return toNumber(left) % toNumber(right);
+    case '^': return toNumber(left) ** toNumber(right);
+    case '&': return `${displayValue(left)}${displayValue(right)}`;
+    case '=': return compare(left, right) === 0;
+    case '<>': return compare(left, right) !== 0;
+    case '<': return compare(left, right) < 0;
+    case '>': return compare(left, right) > 0;
+    case '<=': return compare(left, right) <= 0;
+    case '>=': return compare(left, right) >= 0;
+    default: throw new Error(`Unknown operator "${op}"`);
+  }
+}
+
+function truthy(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'number') return value !== 0;
+  if (typeof value === 'string') {
+    if (value.toUpperCase() === 'TRUE') return true;
+    if (value.toUpperCase() === 'FALSE') return false;
+    return value !== '';
+  }
+  return Boolean(value);
+}
+
+export function displayValue(value) {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? String(value) : String(Math.round(value * 1e10) / 1e10);
+  }
+  if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE';
+  return String(value);
+}

package/src/index.js

@@ -0,0 +1,20 @@
+/**
+ * data-table package entry point.
+ *
+ * This is the only public entry of the npm package. Importing it registers
+ * the <data-table> custom element (see table-component.js) and exports its
+ * class for programmatic use:
+ *
+ *   import '@lnsy/data-table';                  // registers <data-table>
+ *   import DataTable from '@lnsy/data-table';   // the element class
+ *
+ * The component stylesheet ships separately:
+ *
+ *   import '@lnsy/data-table/data-table.css';
+ *
+ * Application/demo wiring (command panel, file menus, endpoint defaults)
+ * is not part of the package — it lives in the repository's root index.js.
+ */
+
+export { default } from './table-component.js';
+export { default as DataTable } from './table-component.js';