@pixerate/editor 0.80.0 → 0.81.0

package/dist/{chunk-UN33YOXW.cjs → chunk-PA5S7KPC.cjs}

@@ -24,6 +24,7 @@
 
 
 
+
 
 
 var _chunkXP5IUZUOcjs = require('./chunk-XP5IUZUO.cjs');
@@ -3480,6 +3481,296 @@ var FormulaEvaluator = (_class2 = class {
   }
 }, _class2);
 
+// src/spreadsheet/table.ts
+function normalizeRange(range) {
+  return {
+    startRow: Math.min(range.startRow, range.endRow),
+    startCol: Math.min(range.startCol, range.endCol),
+    endRow: Math.max(range.startRow, range.endRow),
+    endCol: Math.max(range.startCol, range.endCol)
+  };
+}
+function rangeContains(range, row, col) {
+  const r = normalizeRange(range);
+  return row >= r.startRow && row <= r.endRow && col >= r.startCol && col <= r.endCol;
+}
+function rangesIntersect(a, b) {
+  const x = normalizeRange(a);
+  const y = normalizeRange(b);
+  return x.startRow <= y.endRow && y.startRow <= x.endRow && x.startCol <= y.endCol && y.startCol <= x.endCol;
+}
+function rangeContainsRange(outer, inner) {
+  const o = normalizeRange(outer);
+  const i = normalizeRange(inner);
+  return i.startRow >= o.startRow && i.endRow <= o.endRow && i.startCol >= o.startCol && i.endCol <= o.endCol;
+}
+function isSingleCellRange(range) {
+  const r = normalizeRange(range);
+  return r.startRow === r.endRow && r.startCol === r.endCol;
+}
+var NUMBER_PATTERN = /^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i;
+var ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+function isBlankValue(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function toNumber2(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (NUMBER_PATTERN.test(trimmed)) return parseFloat(trimmed);
+  }
+  return null;
+}
+var collator = typeof Intl !== "undefined" ? new Intl.Collator(void 0, { numeric: true, sensitivity: "base" }) : null;
+function compareText(a, b) {
+  return collator ? collator.compare(a, b) : a < b ? -1 : a > b ? 1 : 0;
+}
+function compareCellValues(a, b, direction = "asc") {
+  const aBlank = isBlankValue(a);
+  const bBlank = isBlankValue(b);
+  if (aBlank || bBlank) return aBlank === bBlank ? 0 : aBlank ? 1 : -1;
+  let result;
+  if (isPlainText(a) && isPlainText(b) && !(_chunkXP5IUZUOcjs.parseIsoDate.call(void 0, a) && _chunkXP5IUZUOcjs.parseIsoDate.call(void 0, b))) {
+    result = compareText(a, b);
+  } else {
+    result = _chunkXP5IUZUOcjs.sortCompareValues.call(void 0, a, b);
+  }
+  if (result === 0) return 0;
+  return direction === "desc" ? -Math.sign(result) : Math.sign(result);
+}
+var isPlainText = (value) => typeof value === "string" && !_chunkXP5IUZUOcjs.isFormulaError.call(void 0, value);
+function filterValue(value) {
+  if (isBlankValue(value) || _chunkXP5IUZUOcjs.isFormulaError.call(void 0, value)) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? { value, kind: "number" } : null;
+  if (typeof value === "boolean") return { value, kind: "boolean" };
+  const num = _chunkXP5IUZUOcjs.numericValue.call(void 0, value);
+  if (num !== null) return { value: num, kind: "number" };
+  const text = String(value);
+  return { value: text, kind: _chunkXP5IUZUOcjs.parseIsoDate.call(void 0, text) ? "number" : "text" };
+}
+function filterOperand(operand) {
+  if (typeof operand !== "string") return filterValue(operand);
+  if (operand.trim() === "") return null;
+  const parsed = _chunkXP5IUZUOcjs.parseCellInput.call(void 0, operand.trim());
+  if (parsed.type === "number" || parsed.type === "date" || parsed.type === "boolean") return filterValue(parsed.value);
+  return { value: operand, kind: "text" };
+}
+function compareForFilter(value, operand) {
+  const a = filterValue(value);
+  const b = filterOperand(operand);
+  if (!a || !b || a.kind !== b.kind) return null;
+  return _chunkXP5IUZUOcjs.compareValues.call(void 0, a.value, b.value);
+}
+function looselyEquals(value, operand) {
+  const c = compareForFilter(value, operand);
+  if (c !== null) return c === 0;
+  return String(_nullishCoalesce(value, () => ( ""))).trim().toLowerCase() === String(_nullishCoalesce(operand, () => ( ""))).trim().toLowerCase();
+}
+function matchesFilterRule(value, rule) {
+  const text = String(_nullishCoalesce(value, () => ( ""))).toLowerCase();
+  switch (rule.operator) {
+    case "equals":
+      return looselyEquals(value, rule.value);
+    case "notEquals":
+      return !looselyEquals(value, rule.value);
+    case "contains":
+      return text.includes(String(_nullishCoalesce(rule.value, () => ( ""))).toLowerCase());
+    case "notContains":
+      return !text.includes(String(_nullishCoalesce(rule.value, () => ( ""))).toLowerCase());
+    case "greaterThan": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c > 0;
+    }
+    case "greaterThanOrEqual": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c >= 0;
+    }
+    case "lessThan": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c < 0;
+    }
+    case "lessThanOrEqual": {
+      const c = compareForFilter(value, rule.value);
+      return c !== null && c <= 0;
+    }
+    case "between": {
+      const lo = compareForFilter(value, rule.value);
+      const hi = compareForFilter(value, rule.value2);
+      return lo !== null && hi !== null && lo >= 0 && hi <= 0;
+    }
+    case "isBlank":
+      return isBlankValue(value);
+    case "isNotBlank":
+      return !isBlankValue(value);
+    case "oneOf":
+      return (_nullishCoalesce(rule.values, () => ( []))).some((candidate) => String(candidate) === String(_nullishCoalesce(value, () => ( ""))));
+    default:
+      return true;
+  }
+}
+function aggregateValues(values, aggregate) {
+  if (aggregate === "count") return values.filter((v) => !isBlankValue(v)).length;
+  const numbers = [];
+  for (const v of values) {
+    const n = toNumber2(v);
+    if (n !== null) numbers.push(n);
+  }
+  if (numbers.length === 0) return aggregate === "sum" ? 0 : null;
+  switch (aggregate) {
+    case "sum":
+      return roundFloat(numbers.reduce((s, n) => s + n, 0));
+    case "average":
+      return roundFloat(numbers.reduce((s, n) => s + n, 0) / numbers.length);
+    case "min":
+      return numbers.reduce((m, n) => n < m ? n : m, numbers[0]);
+    case "max":
+      return numbers.reduce((m, n) => n > m ? n : m, numbers[0]);
+    default:
+      return null;
+  }
+}
+function roundFloat(value) {
+  return Number.isInteger(value) ? value : parseFloat(value.toPrecision(12));
+}
+var DAY_MS = 864e5;
+var TRAILING_NUMBER = /^(.*?)(\d+)(\D*)$/;
+function classifyFillValue(raw) {
+  if (raw.trim() === "") return { kind: "blank" };
+  const num = toNumber2(raw);
+  if (num !== null) return { kind: "number", value: num };
+  const typed = _chunkXP5IUZUOcjs.parseCellInput.call(void 0, raw);
+  const date = ISO_DATE_PATTERN.exec(typed.type === "date" ? String(typed.value) : raw.trim());
+  if (date) {
+    const [year, month, day] = [Number(date[1]), Number(date[2]), Number(date[3])];
+    const time = Date.UTC(year, month - 1, day);
+    const check2 = new Date(time);
+    if (check2.getUTCMonth() === month - 1 && check2.getUTCDate() === day) {
+      return { kind: "date", time, year, month, day };
+    }
+  }
+  const textNumber = TRAILING_NUMBER.exec(raw);
+  if (textNumber && textNumber[1] !== "") {
+    return {
+      kind: "textNumber",
+      prefix: textNumber[1],
+      value: parseInt(textNumber[2], 10),
+      width: textNumber[2].length,
+      suffix: textNumber[3]
+    };
+  }
+  return { kind: "text", text: raw };
+}
+var pad = (n, width) => String(Math.abs(n)).padStart(width, "0");
+function formatDate(time) {
+  const d = new Date(time);
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1, 2)}-${pad(d.getUTCDate(), 2)}`;
+}
+function constantStep(values) {
+  const step = values[1] - values[0];
+  for (let i = 2; i < values.length; i++) {
+    if (Math.abs(values[i] - values[i - 1] - step) > 1e-9) return null;
+  }
+  return step;
+}
+function linearTrend(values, x) {
+  const n = values.length;
+  const meanX = (n - 1) / 2;
+  const meanY = values.reduce((s, v) => s + v, 0) / n;
+  let num = 0;
+  let den = 0;
+  values.forEach((v, i) => {
+    num += (i - meanX) * (v - meanY);
+    den += (i - meanX) ** 2;
+  });
+  const slope = den === 0 ? 0 : num / den;
+  return meanY + slope * (x - meanX);
+}
+function fillSeries(source, count) {
+  if (count <= 0) return [];
+  if (source.length === 0) return Array(count).fill("");
+  const repeat = () => Array.from({ length: count }, (_, i) => source[i % source.length]);
+  const parsed = source.map(classifyFillValue);
+  const kind = parsed[0].kind;
+  if (!parsed.every((p) => p.kind === kind)) return repeat();
+  const n = source.length;
+  if (kind === "number") {
+    if (n === 1) return repeat();
+    const values = parsed.map((p) => p.value);
+    return Array.from({ length: count }, (_, i) => String(roundFloat(linearTrend(values, n + i))));
+  }
+  if (kind === "date") {
+    const dates = parsed;
+    if (n === 1) {
+      return Array.from({ length: count }, (_, i) => formatDate(dates[0].time + (i + 1) * DAY_MS));
+    }
+    const monthIndex = dates.map((d) => d.year * 12 + (d.month - 1));
+    const monthStep = constantStep(monthIndex);
+    if (monthStep !== null && monthStep !== 0 && dates.every((d) => d.day === dates[0].day)) {
+      const last = monthIndex[n - 1];
+      return Array.from({ length: count }, (_, i) => {
+        const m = last + monthStep * (i + 1);
+        const year = Math.floor(m / 12);
+        const month = m - year * 12;
+        const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+        return formatDate(Date.UTC(year, month, Math.min(dates[0].day, daysInMonth)));
+      });
+    }
+    const dayStep = constantStep(dates.map((d) => Math.round(d.time / DAY_MS)));
+    if (dayStep === null) return repeat();
+    const lastTime = dates[n - 1].time;
+    return Array.from({ length: count }, (_, i) => formatDate(lastTime + dayStep * (i + 1) * DAY_MS));
+  }
+  if (kind === "textNumber") {
+    const items = parsed;
+    const { prefix, suffix } = items[0];
+    if (!items.every((t) => t.prefix === prefix && t.suffix === suffix)) return repeat();
+    const step = n === 1 ? 1 : constantStep(items.map((t) => t.value));
+    if (step === null) return repeat();
+    const last = items[n - 1];
+    return Array.from({ length: count }, (_, i) => {
+      const value = last.value + step * (i + 1);
+      const digits = value < 0 ? `-${pad(value, last.width)}` : pad(value, last.width);
+      return `${prefix}${digits}${suffix}`;
+    });
+  }
+  return repeat();
+}
+function computeFillTarget(source, pointer) {
+  const s = normalizeRange(source);
+  const rowOverflow = pointer.row > s.endRow ? pointer.row - s.endRow : pointer.row < s.startRow ? s.startRow - pointer.row : 0;
+  const colOverflow = pointer.col > s.endCol ? pointer.col - s.endCol : pointer.col < s.startCol ? s.startCol - pointer.col : 0;
+  if (rowOverflow === 0 && colOverflow === 0) return null;
+  if (rowOverflow >= colOverflow) {
+    return pointer.row > s.endRow ? { ...s, endRow: pointer.row } : { ...s, startRow: pointer.row };
+  }
+  return pointer.col > s.endCol ? { ...s, endCol: pointer.col } : { ...s, startCol: pointer.col };
+}
+function getFillDirection(source, target) {
+  const s = normalizeRange(source);
+  const t = normalizeRange(target);
+  const sameCols = s.startCol === t.startCol && s.endCol === t.endCol;
+  const sameRows = s.startRow === t.startRow && s.endRow === t.endRow;
+  if (sameCols && t.startRow === s.startRow && t.endRow > s.endRow) return "down";
+  if (sameCols && t.endRow === s.endRow && t.startRow < s.startRow) return "up";
+  if (sameRows && t.startCol === s.startCol && t.endCol > s.endCol) return "right";
+  if (sameRows && t.endCol === s.endCol && t.startCol < s.startCol) return "left";
+  return null;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -3504,5 +3795,5 @@ var FormulaEvaluator = (_class2 = class {
 
 
 
-exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.FormulaLambda = FormulaLambda; exports.isFormulaLambda = isFormulaLambda; exports.MAX_LAMBDA_DEPTH = MAX_LAMBDA_DEPTH; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
-//# sourceMappingURL=chunk-UN33YOXW.cjs.map
+exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.FormulaLambda = FormulaLambda; exports.isFormulaLambda = isFormulaLambda; exports.MAX_LAMBDA_DEPTH = MAX_LAMBDA_DEPTH; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator; exports.normalizeRange = normalizeRange; exports.rangeContains = rangeContains; exports.rangesIntersect = rangesIntersect; exports.rangeContainsRange = rangeContainsRange; exports.isSingleCellRange = isSingleCellRange; exports.isBlankValue = isBlankValue; exports.toNumber = toNumber2; exports.compareCellValues = compareCellValues; exports.matchesFilterRule = matchesFilterRule; exports.aggregateValues = aggregateValues; exports.roundFloat = roundFloat; exports.fillSeries = fillSeries; exports.computeFillTarget = computeFillTarget; exports.getFillDirection = getFillDirection;
+//# sourceMappingURL=chunk-PA5S7KPC.cjs.map