@braincrew-lab/langchain-canvas 0.2.0 → 0.4.9

package/dist/chunk-IFNRLN4Y.js

@@ -0,0 +1,137 @@
+// src/io/tableMerge.ts
+var isFormula = (v) => typeof v === "string" && v.startsWith("=");
+var VALUE_KEYS = ["v", "m", "ct", "f", "qp", "spl"];
+function normalizedValue(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : null;
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  const text = String(value).trim();
+  if (text === "") return null;
+  const num = Number(text);
+  return Number.isNaN(num) ? text : String(num);
+}
+var normalizedFormula = (f) => typeof f === "string" && f.trim() ? f.trim().replace(/^=/, "") : null;
+function sameCellContent(rowsValue, cellV) {
+  const cellFormula = cellV && typeof cellV === "object" ? normalizedFormula(cellV.f) : null;
+  if (isFormula(rowsValue) || cellFormula !== null) {
+    return normalizedFormula(rowsValue) === cellFormula;
+  }
+  const cellValue = cellV && typeof cellV === "object" ? cellV.v ?? cellV.m ?? null : cellV;
+  return normalizedValue(rowsValue) === normalizedValue(cellValue);
+}
+function cellMap(sheet) {
+  const map = /* @__PURE__ */ new Map();
+  if (sheet.celldata?.length) {
+    for (const cell of sheet.celldata) {
+      if (cell?.v != null) map.set(`${cell.r},${cell.c}`, cell.v);
+    }
+    return map;
+  }
+  (sheet.data ?? []).forEach(
+    (row, r) => (row ?? []).forEach((cell, c) => {
+      if (cell != null) map.set(`${r},${c}`, cell);
+    })
+  );
+  return map;
+}
+function projectedValue(cellV) {
+  if (cellV === null || cellV === void 0) return "";
+  if (typeof cellV !== "object") return cellV;
+  const f = normalizedFormula(cellV.f);
+  if (f !== null) return `=${f}`;
+  const v = cellV.v ?? cellV.m;
+  return v === null || v === void 0 ? "" : v;
+}
+function projectSheetIntoRows(columns, rows, sheet) {
+  const first = sheet?.[0];
+  if (!first || columns.length === 0) return rows;
+  const cells = cellMap(first);
+  let deepest = 0;
+  for (const key of cells.keys()) {
+    const [r, c] = key.split(",").map(Number);
+    if (r >= 1 && c < columns.length) deepest = Math.max(deepest, r);
+  }
+  const projected = [];
+  for (let i = 0; i < deepest; i++) {
+    const row = { ...rows[i] ?? {} };
+    columns.forEach((col, c) => {
+      row[col.key] = projectedValue(cells.get(`${i + 1},${c}`));
+    });
+    projected.push(row);
+  }
+  return projected;
+}
+function valueCell(rowsValue, dataIdx, col, formulas) {
+  if (rowsValue === null || rowsValue === void 0 || rowsValue === "") return null;
+  if (isFormula(rowsValue)) {
+    const out = { f: rowsValue };
+    const computed = formulas?.get(`${dataIdx + 1},${col}`);
+    if (computed !== void 0) {
+      out.v = computed;
+      out.m = String(computed);
+      if (typeof computed === "number") out.ct = { fa: "General", t: "n" };
+    }
+    return out;
+  }
+  const numeric = typeof rowsValue === "number";
+  return { v: rowsValue, m: String(rowsValue), ...numeric ? { ct: { fa: "General", t: "n" } } : {} };
+}
+function mergeRowsIntoSheet(columns, rows, sheet, formulas) {
+  const first = sheet?.[0];
+  if (!first || columns.length === 0) return sheet;
+  const cells = cellMap(first);
+  const overrides = /* @__PURE__ */ new Map();
+  columns.forEach((col, c) => {
+    const label = col.label ?? col.key;
+    if (!sameCellContent(label, cells.get(`0,${c}`))) {
+      overrides.set(`0,${c}`, { v: label, m: String(label) });
+    }
+    rows.forEach((row, i) => {
+      const value = row[col.key];
+      if (!sameCellContent(value, cells.get(`${i + 1},${c}`))) {
+        overrides.set(`${i + 1},${c}`, valueCell(value, i, c, formulas));
+      }
+    });
+  });
+  const inRectangle = (r, c) => c < columns.length && r >= 1;
+  const ghosts = [...cells.keys()].filter((key) => {
+    const [r, c] = key.split(",").map(Number);
+    return inRectangle(r, c) && r > rows.length;
+  });
+  if (overrides.size === 0 && ghosts.length === 0) return sheet;
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, existing] of cells) {
+    const [r, c] = key.split(",").map(Number);
+    seen.add(key);
+    if (inRectangle(r, c) && r > rows.length) continue;
+    if (!overrides.has(key)) {
+      merged.push({ r, c, v: existing });
+      continue;
+    }
+    const next = overrides.get(key);
+    const style = existing && typeof existing === "object" ? Object.fromEntries(
+      Object.entries(existing).filter(
+        ([k]) => !VALUE_KEYS.includes(k)
+      )
+    ) : {};
+    const v = next === null ? style : { ...style, ...next };
+    if (Object.keys(v).length > 0) merged.push({ r, c, v });
+  }
+  for (const [key, next] of overrides) {
+    if (seen.has(key) || next === null) continue;
+    const [r, c] = key.split(",").map(Number);
+    merged.push({ r, c, v: next });
+  }
+  merged.sort((a, b) => a.r - b.r || a.c - b.c);
+  const { data: _data, ...rest } = first;
+  const mergedFirst = {
+    ...rest,
+    celldata: merged,
+    row: Math.max(Number(first.row) || 0, rows.length + 40),
+    column: Math.max(Number(first.column) || 0, columns.length + 2)
+  };
+  return [mergedFirst, ...(sheet ?? []).slice(1)];
+}
+
+export { mergeRowsIntoSheet, projectSheetIntoRows };

package/dist/{chunk-UL5F66PN.js → chunk-K2UZAYW2.js}

@@ -1,4 +1,4 @@
-import { useCanvasStore } from './chunk-S54GJDSJ.js';
+import { useCanvasStore } from './chunk-EHW446VF.js';
 import { useCallback } from 'react';
 
 function useArtifactPatch(id) {

package/dist/chunk-SGOPRUQ4.js

@@ -0,0 +1,182 @@
+import { loadOptional } from './chunk-YZZSJJMQ.js';
+
+// src/io/formulaFunctions.ts
+var unwrap = (arg) => arg !== null && typeof arg === "object" && !Array.isArray(arg) && "value" in arg ? arg.value : arg;
+var flat = (arg) => {
+  const value = unwrap(arg);
+  return Array.isArray(value) ? value.flat(Infinity) : [value];
+};
+var scalar = (arg) => flat(arg)[0] ?? null;
+var numbers = (values) => values.flatMap(flat).filter((v) => typeof v === "number");
+var ciEqual = (a, b) => String(a ?? "").toLowerCase() === b.toLowerCase();
+var matchesCriteria = (value, criteria) => {
+  if (typeof criteria === "string") {
+    const m = /^(<>|>=|<=|=|>|<)(.*)$/.exec(criteria);
+    if (m) {
+      const [, op, rest] = m;
+      const num2 = rest.trim() === "" ? NaN : Number(rest);
+      if (!Number.isNaN(num2)) {
+        if (op === "=") return value === num2;
+        if (op === "<>") return value !== num2;
+        if (typeof value !== "number") return false;
+        return op === ">" ? value > num2 : op === "<" ? value < num2 : op === ">=" ? value >= num2 : value <= num2;
+      }
+      if (op === "=") return ciEqual(value, rest);
+      if (op === "<>") return !ciEqual(value, rest);
+      const a = String(value ?? "").toLowerCase();
+      const b = rest.toLowerCase();
+      return op === ">" ? a > b : op === "<" ? a < b : op === ">=" ? a >= b : a <= b;
+    }
+    const num = criteria.trim() === "" ? NaN : Number(criteria);
+    if (!Number.isNaN(num)) return value === num;
+    return typeof value === "string" && ciEqual(value, criteria);
+  }
+  return value === criteria;
+};
+var criteriaPairs = (args, length) => {
+  if (args.length === 0 || args.length % 2 !== 0) throw new Error("criteria come in range/criteria pairs");
+  const pairs = [];
+  for (let i = 0; i < args.length; i += 2) {
+    const range = flat(args[i]);
+    if (range.length !== length) throw new Error("criteria ranges must match the first range's size");
+    pairs.push({ range, criteria: scalar(args[i + 1]) });
+  }
+  return pairs;
+};
+var matchingIndexes = (pairs, length) => {
+  const out = [];
+  for (let i = 0; i < length; i++) {
+    if (pairs.every(({ range, criteria }) => matchesCriteria(range[i], criteria))) out.push(i);
+  }
+  return out;
+};
+var truthy = (v) => v === true || v === 1 || typeof v === "string" && v.toUpperCase() === "TRUE";
+var text = (v) => typeof v === "boolean" ? v ? "TRUE" : "FALSE" : String(v ?? "");
+function customFormulaFunctions() {
+  return {
+    SUMIFS: (sumRange, ...rest) => {
+      const sums = flat(sumRange);
+      const pairs = criteriaPairs(rest, sums.length);
+      return matchingIndexes(pairs, sums.length).reduce((acc, i) => {
+        const v = sums[i];
+        return typeof v === "number" ? acc + v : acc;
+      }, 0);
+    },
+    AVERAGEIFS: (avgRange, ...rest) => {
+      const values = flat(avgRange);
+      const pairs = criteriaPairs(rest, values.length);
+      const hits = matchingIndexes(pairs, values.length).map((i) => values[i]).filter((v) => typeof v === "number");
+      if (hits.length === 0) throw new Error("AVERAGEIFS matched no cells");
+      return hits.reduce((a, b) => a + b, 0) / hits.length;
+    },
+    COUNTIFS: (...rest) => {
+      const length = flat(rest[0]).length;
+      return matchingIndexes(criteriaPairs(rest, length), length).length;
+    },
+    MATCH: (lookup, range, matchType) => {
+      const values = flat(range);
+      const target = scalar(lookup);
+      const rawMode = matchType === void 0 ? null : scalar(matchType);
+      const mode = typeof rawMode === "number" ? rawMode : 1;
+      const equals = (v) => typeof target === "string" ? ciEqual(v, target) : v === target;
+      if (mode === 0) {
+        const idx = values.findIndex(equals);
+        if (idx === -1) throw new Error("MATCH found no exact match");
+        return idx + 1;
+      }
+      let found = -1;
+      for (let i = 0; i < values.length; i++) {
+        const v = values[i];
+        if (typeof v !== typeof target || v === null || target === null) continue;
+        if (mode === 1 ? v <= target : v >= target) found = i;
+        else break;
+      }
+      if (found === -1) throw new Error("MATCH found no match");
+      return found + 1;
+    },
+    MAX: (...args) => {
+      const nums = numbers(args);
+      return nums.length ? Math.max(...nums) : 0;
+    },
+    MIN: (...args) => {
+      const nums = numbers(args);
+      return nums.length ? Math.min(...nums) : 0;
+    },
+    TEXTJOIN: (delimiter, ignoreEmpty, ...parts) => {
+      const values = parts.flatMap(flat);
+      const kept = truthy(scalar(ignoreEmpty)) ? values.filter((v) => v !== null && v !== "") : values;
+      return kept.map(text).join(text(scalar(delimiter)));
+    }
+  };
+}
+
+// src/io/formula.ts
+var EMPTY = /* @__PURE__ */ new Map();
+async function computeFormulas(columns, rows) {
+  const formulaCells = [];
+  rows.forEach(
+    (row, dataIdx) => columns.forEach((col, c) => {
+      const v = row[col.key];
+      if (typeof v === "string" && v.startsWith("=")) formulaCells.push({ dataIdx, col: c, formula: v });
+    })
+  );
+  if (formulaCells.length === 0) return EMPTY;
+  const mod = await loadOptional("fast-formula-parser", () => import('fast-formula-parser'));
+  const FormulaParser = mod.default ?? mod;
+  const memo = /* @__PURE__ */ new Map();
+  const inProgress = /* @__PURE__ */ new Set();
+  const rawAt = (row, col) => {
+    const colIdx = col - 1;
+    if (row === 1) return columns[colIdx]?.label ?? columns[colIdx]?.key ?? null;
+    const dataRow = rows[row - 2];
+    const column = columns[colIdx];
+    if (!dataRow || !column) return null;
+    const v = dataRow[column.key];
+    return v ?? null;
+  };
+  const valueAt = (row, col) => {
+    const raw = rawAt(row, col);
+    if (typeof raw !== "string" || !raw.startsWith("=")) return raw ?? 0;
+    const key = `${row},${col}`;
+    const cached = memo.get(key);
+    if (cached !== void 0) return cached;
+    if (inProgress.has(key)) return 0;
+    inProgress.add(key);
+    const value = evaluate(raw, row, col);
+    inProgress.delete(key);
+    memo.set(key, value);
+    return value;
+  };
+  const parser = new FormulaParser({
+    // Overrides the library's empty classic-function stubs (SUMIFS, MATCH, …).
+    functions: customFormulaFunctions(),
+    onCell: ({ row, col }) => valueAt(row, col),
+    onRange: (ref) => {
+      const maxRow = Math.min(ref.to.row, rows.length + 1);
+      const maxCol = Math.min(ref.to.col, columns.length);
+      const grid = [];
+      for (let r = ref.from.row; r <= maxRow; r++) {
+        const line = [];
+        for (let c = ref.from.col; c <= maxCol; c++) line.push(valueAt(r, c));
+        grid.push(line);
+      }
+      return grid;
+    }
+  });
+  const evaluate = (formula, row, col) => {
+    try {
+      const result = parser.parse(formula.slice(1), { row, col });
+      if (result != null && typeof result === "object") return "#ERR";
+      return result ?? 0;
+    } catch {
+      return "#ERR";
+    }
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const { dataIdx, col, formula } of formulaCells) {
+    out.set(`${dataIdx + 1},${col}`, evaluate(formula, dataIdx + 2, col + 1));
+  }
+  return out;
+}
+
+export { computeFormulas };

package/dist/formula-27TCEZI5.js

@@ -0,0 +1,2 @@
+export { computeFormulas } from './chunk-SGOPRUQ4.js';
+import './chunk-YZZSJJMQ.js';

package/dist/formula-cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/formula-cli.js

@@ -0,0 +1,37 @@
+import { computeFormulas } from './chunk-SGOPRUQ4.js';
+import './chunk-YZZSJJMQ.js';
+
+// src/io/formulaCli.ts
+async function main() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const input = new TextDecoder().decode(
+    chunks.reduce((acc, c) => {
+      const merged = new Uint8Array(acc.length + c.length);
+      merged.set(acc);
+      merged.set(c, acc.length);
+      return merged;
+    }, new Uint8Array())
+  );
+  const { columns, rows } = JSON.parse(input);
+  const values = await computeFormulas(columns ?? [], rows ?? []);
+  const results = [];
+  (rows ?? []).forEach(
+    (row, dataIdx) => (columns ?? []).forEach((col, colIdx) => {
+      const v = row[col.key];
+      if (typeof v !== "string" || !v.startsWith("=")) return;
+      results.push({
+        row: dataIdx,
+        col: colIdx,
+        key: col.key,
+        formula: v,
+        value: values.get(`${dataIdx + 1},${colIdx}`) ?? null
+      });
+    })
+  );
+  process.stdout.write(JSON.stringify({ results }));
+}
+main().catch((error) => {
+  process.stdout.write(JSON.stringify({ error: String(error) }));
+  process.exitCode = 1;
+});