@bendyline/squisq 2.10.0 → 2.11.0

package/dist/table/index.js

@@ -0,0 +1,298 @@
+// src/table/viewState.ts
+var TEXT_FILTER_OPS = ["=", "!=", "~", "!~", "^~", "$~"];
+var EMPTY_TABLE_VIEW_STATE = Object.freeze({
+  sort: [],
+  filter: []
+});
+function isEmptyViewState(view) {
+  return view.sort.length === 0 && view.filter.length === 0;
+}
+function isNumericCellText(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return false;
+  if (/^0\d/.test(trimmed)) return false;
+  return Number.isFinite(Number(trimmed));
+}
+function inferNumericColumn(rows, col) {
+  let sawValue = false;
+  for (const row of rows) {
+    const cell = row[col] ?? "";
+    if (cell.trim() === "") continue;
+    if (!isNumericCellText(cell)) return false;
+    sawValue = true;
+  }
+  return sawValue;
+}
+function makeTableCollator() {
+  return new Intl.Collator(void 0, { numeric: true });
+}
+var NEEDS_INNER_QUOTING_RE = /[,:;=!<>~"^$*]|^\s|\s$/;
+function quoteViewToken(text) {
+  if (text === "" || NEEDS_INNER_QUOTING_RE.test(text)) {
+    return `"${text.replace(/"/g, '""')}"`;
+  }
+  return text;
+}
+function readQuoted(scanner) {
+  let out = "";
+  let i = scanner.pos + 1;
+  const { text } = scanner;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      if (text[i + 1] === '"') {
+        out += '"';
+        i += 2;
+        continue;
+      }
+      scanner.pos = i + 1;
+      return out;
+    }
+    out += ch;
+    i++;
+  }
+  return null;
+}
+function readBare(scanner, stops) {
+  const { text } = scanner;
+  let i = scanner.pos;
+  while (i < text.length && !stops.includes(text[i])) i++;
+  const out = text.slice(scanner.pos, i);
+  scanner.pos = i;
+  return out.trim();
+}
+function skipSpaces(scanner) {
+  while (scanner.text[scanner.pos] === " ") scanner.pos++;
+}
+var FILTER_OP_TOKENS = [
+  { token: ">=", op: ">=", caseSensitive: false },
+  { token: "<=", op: "<=", caseSensitive: false },
+  { token: "!~*", op: "!~", caseSensitive: true },
+  { token: "!~", op: "!~", caseSensitive: false },
+  { token: "!=*", op: "!=", caseSensitive: true },
+  { token: "!=", op: "!=", caseSensitive: false },
+  { token: "^~*", op: "^~", caseSensitive: true },
+  { token: "^~", op: "^~", caseSensitive: false },
+  { token: "$~*", op: "$~", caseSensitive: true },
+  { token: "$~", op: "$~", caseSensitive: false },
+  { token: "~*", op: "~", caseSensitive: true },
+  { token: "~", op: "~", caseSensitive: false },
+  { token: "=*", op: "=", caseSensitive: true },
+  { token: "=", op: "=", caseSensitive: false },
+  { token: ">", op: ">", caseSensitive: false },
+  { token: "<", op: "<", caseSensitive: false }
+];
+function parseSortParam(raw) {
+  const scanner = { text: raw, pos: 0 };
+  const terms = [];
+  for (; ; ) {
+    skipSpaces(scanner);
+    const column = scanner.text[scanner.pos] === '"' ? readQuoted(scanner) : readBare(scanner, ":,");
+    if (column === null || column === "") return null;
+    let dir = "asc";
+    skipSpaces(scanner);
+    if (scanner.text[scanner.pos] === ":") {
+      scanner.pos++;
+      skipSpaces(scanner);
+      const dirToken = readBare(scanner, ",").toLowerCase();
+      if (dirToken !== "asc" && dirToken !== "desc") return null;
+      dir = dirToken;
+    }
+    terms.push({ column, dir });
+    skipSpaces(scanner);
+    if (scanner.pos >= scanner.text.length) return terms;
+    if (scanner.text[scanner.pos] !== ",") return null;
+    scanner.pos++;
+  }
+}
+function parseFilterParam(raw) {
+  const scanner = { text: raw, pos: 0 };
+  const clauses = [];
+  for (; ; ) {
+    skipSpaces(scanner);
+    const column = scanner.text[scanner.pos] === '"' ? readQuoted(scanner) : readBare(scanner, "=!<>~^$;");
+    if (column === null || column === "") return null;
+    skipSpaces(scanner);
+    const rest = scanner.text.slice(scanner.pos);
+    const match = FILTER_OP_TOKENS.find((candidate) => rest.startsWith(candidate.token));
+    if (!match) return null;
+    scanner.pos += match.token.length;
+    skipSpaces(scanner);
+    const value = scanner.text[scanner.pos] === '"' ? readQuoted(scanner) : readBare(scanner, ";");
+    if (value === null) return null;
+    const clause = { column, op: match.op, value };
+    if (match.caseSensitive) clause.caseSensitive = true;
+    clauses.push(clause);
+    skipSpaces(scanner);
+    if (scanner.pos >= scanner.text.length) return clauses;
+    if (scanner.text[scanner.pos] !== ";") return null;
+    scanner.pos++;
+  }
+}
+function parseTableViewState(sortRaw, filterRaw, headers) {
+  const issues = [];
+  const known = new Set(headers);
+  let sort = [];
+  if (sortRaw !== void 0 && sortRaw.trim() !== "") {
+    const parsed = parseSortParam(sortRaw);
+    if (parsed === null) {
+      issues.push({ code: "data-view-invalid", message: `sort "${sortRaw}" could not be parsed` });
+    } else {
+      sort = parsed.filter((term) => {
+        if (known.has(term.column)) return true;
+        issues.push({
+          code: "data-view-unknown-column",
+          message: `sort column "${term.column}" is not a header`
+        });
+        return false;
+      });
+    }
+  }
+  let filter = [];
+  if (filterRaw !== void 0 && filterRaw.trim() !== "") {
+    const parsed = parseFilterParam(filterRaw);
+    if (parsed === null) {
+      issues.push({
+        code: "data-view-invalid",
+        message: `filter "${filterRaw}" could not be parsed`
+      });
+    } else {
+      filter = parsed.filter((clause) => {
+        if (known.has(clause.column)) return true;
+        issues.push({
+          code: "data-view-unknown-column",
+          message: `filter column "${clause.column}" is not a header`
+        });
+        return false;
+      });
+    }
+  }
+  return { view: { sort, filter }, issues };
+}
+function serializeTableViewState(view) {
+  const out = {};
+  if (view.sort.length > 0) {
+    out.sort = view.sort.map((term) => `${quoteViewToken(term.column)}${term.dir === "desc" ? ":desc" : ""}`).join(",");
+  }
+  if (view.filter.length > 0) {
+    out.filter = view.filter.map((clause) => {
+      const star = clause.caseSensitive === true && TEXT_FILTER_OPS.includes(clause.op) ? "*" : "";
+      return `${quoteViewToken(clause.column)}${clause.op}${star}${quoteViewToken(clause.value)}`;
+    }).join(";");
+  }
+  return out;
+}
+
+// src/table/applyTableViewState.ts
+function matchesClause(cell, clause, numericColumn, collator) {
+  const cellTrim = cell.trim();
+  const valueTrim = clause.value.trim();
+  const blank = cellTrim === "";
+  const fold = (text) => clause.caseSensitive ? text : text.toLowerCase();
+  switch (clause.op) {
+    case "=":
+      if (valueTrim === "") return blank;
+      if (blank) return false;
+      if (numericColumn && isNumericCellText(valueTrim)) {
+        return Number(cellTrim) === Number(valueTrim);
+      }
+      return fold(cellTrim) === fold(valueTrim);
+    case "!=":
+      return !matchesClause(cell, { ...clause, op: "=" }, numericColumn, collator);
+    case "~":
+      return !blank && fold(cellTrim).includes(fold(valueTrim));
+    case "!~":
+      return !matchesClause(cell, { ...clause, op: "~" }, numericColumn, collator);
+    case "^~":
+      return !blank && fold(cellTrim).startsWith(fold(valueTrim));
+    case "$~":
+      return !blank && fold(cellTrim).endsWith(fold(valueTrim));
+    case ">":
+    case "<":
+    case ">=":
+    case "<=": {
+      if (blank) return false;
+      let comparison;
+      if (numericColumn && isNumericCellText(valueTrim)) {
+        comparison = Number(cellTrim) - Number(valueTrim);
+      } else {
+        comparison = collator.compare(cellTrim, valueTrim);
+      }
+      if (clause.op === ">") return comparison > 0;
+      if (clause.op === "<") return comparison < 0;
+      if (clause.op === ">=") return comparison >= 0;
+      return comparison <= 0;
+    }
+  }
+}
+function applyTableViewState(headers, rows, view) {
+  const asMutable = rows;
+  if (isEmptyViewState(view)) {
+    return {
+      rows: [...asMutable],
+      rowIds: rows.map((_, index) => index),
+      unfilteredRowCount: rows.length
+    };
+  }
+  const collator = makeTableCollator();
+  const columnIndex = new Map(headers.map((header, index) => [header, index]));
+  const numericByCol = /* @__PURE__ */ new Map();
+  const numericFor = (col) => {
+    let cached = numericByCol.get(col);
+    if (cached === void 0) {
+      cached = inferNumericColumn(rows, col);
+      numericByCol.set(col, cached);
+    }
+    return cached;
+  };
+  const clauses = view.filter.map((clause) => ({ clause, col: columnIndex.get(clause.column) })).filter((entry) => entry.col !== void 0);
+  let rowIds = [];
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    let pass = true;
+    for (const { clause, col } of clauses) {
+      if (!matchesClause(row[col] ?? "", clause, numericFor(col), collator)) {
+        pass = false;
+        break;
+      }
+    }
+    if (pass) rowIds.push(index);
+  }
+  const terms = view.sort.map((term) => ({ term, col: columnIndex.get(term.column) })).filter(
+    (entry) => entry.col !== void 0
+  );
+  if (terms.length > 0) {
+    for (const { col } of terms) numericFor(col);
+    rowIds = [...rowIds].sort((a, b) => {
+      for (const { term, col } of terms) {
+        const left = (rows[a][col] ?? "").trim();
+        const right = (rows[b][col] ?? "").trim();
+        const leftBlank = left === "";
+        const rightBlank = right === "";
+        if (leftBlank || rightBlank) {
+          if (leftBlank && rightBlank) continue;
+          return leftBlank ? 1 : -1;
+        }
+        const comparison = numericByCol.get(col) ? Number(left) - Number(right) : collator.compare(left, right);
+        if (comparison !== 0) return term.dir === "desc" ? -comparison : comparison;
+      }
+      return a - b;
+    });
+  }
+  return {
+    rows: rowIds.map((id) => asMutable[id]),
+    rowIds,
+    unfilteredRowCount: rows.length
+  };
+}
+export {
+  EMPTY_TABLE_VIEW_STATE,
+  applyTableViewState,
+  inferNumericColumn,
+  isEmptyViewState,
+  isNumericCellText,
+  makeTableCollator,
+  parseTableViewState,
+  quoteViewToken,
+  serializeTableViewState
+};

package/dist/{themeLibrary-xaxN5UYu.d.ts → themeLibrary-BG3jr6mT.d.ts}

@@ -1,4 +1,4 @@
-import { bh as Theme, bl as ThemeRegistry } from './Doc-DTyeaFuW.js';
+import { bh as Theme, bl as ThemeRegistry } from './Doc-CRPQCkHn.js';
 
 /**
  * Built-in Theme Library

package/dist/transform/index.d.ts

@@ -1,5 +1,5 @@
-import { r as ColorScheme, O as Doc, k as Block } from '../Doc-DTyeaFuW.js';
-import { i as PageTransformHints } from '../materializePageSection-BRNIINlU.js';
+import { r as ColorScheme, O as Doc, k as Block } from '../Doc-CRPQCkHn.js';
+import { i as PageTransformHints } from '../materializePageSection-BeUPHeCl.js';
 import { d as ExtractionType, E as ExtractedElement, b as ExtractionOptions } from '../contentExtractor-BNfVJV2U.js';
 import '../types-Be6sBUBx.js';
 

package/dist/versions/index.d.ts

@@ -128,5 +128,19 @@ declare function parseVersionPath(path: string): {
     timestamp: Date;
     collision: number;
 } | null;
+/** Subfolder holding pre-save backups of DATA sidecar files. */
+declare const DATA_BACKUP_PREFIX = ".versions/data/";
+/**
+ * Build a pre-save backup path for a data sidecar file:
+ * `.versions/data/<path with '/' → '__'>.<stamp>[-n].<ext>`.
+ *
+ * The grid's save flow writes the ORIGINAL bytes here before overwriting a
+ * sidecar in place — the only cross-save undo the grid offers. Unlike
+ * `buildVersionPath` (markdown-only, single-basename), the flattened full
+ * path keeps same-named files in different folders distinct, and the
+ * extension follows the sidecar. The flattened name goes through the same
+ * safety rules as document snapshots (via a per-call strategy).
+ */
+declare function buildDataBackupPath(sidecarPath: string, date: Date, collision?: number): string;
 
-export { CoalesceOptions, DocumentVersionManager, type DocumentVersionManagerOptions, PrunePolicy, RevertOptions, RevertResult, SaveVersionOptions, SaveVersionResult, VERSIONS_PREFIX, VERSION_TIMESTAMP_PATTERN, Version, buildVersionPath, coalesceVersions, formatVersionTimestamp, getDocBasename, listVersions, parseVersionPath, parseVersionTimestamp, pruneVersions, readVersion, revertToVersion, saveVersion };
+export { CoalesceOptions, DATA_BACKUP_PREFIX, DocumentVersionManager, type DocumentVersionManagerOptions, PrunePolicy, RevertOptions, RevertResult, SaveVersionOptions, SaveVersionResult, VERSIONS_PREFIX, VERSION_TIMESTAMP_PATTERN, Version, buildDataBackupPath, buildVersionPath, coalesceVersions, formatVersionTimestamp, getDocBasename, listVersions, parseVersionPath, parseVersionTimestamp, pruneVersions, readVersion, revertToVersion, saveVersion };

package/dist/versions/index.js

@@ -1,6 +1,8 @@
 import {
+  DATA_BACKUP_PREFIX,
   DocumentVersionManager,
   VERSIONS_PREFIX,
+  buildDataBackupPath,
   buildVersionPath,
   coalesceVersions,
   getDocBasename,
@@ -10,16 +12,18 @@ import {
   readVersion,
   revertToVersion,
   saveVersion
-} from "../chunk-7YEZFHLS.js";
+} from "../chunk-O7HLQ22N.js";
 import {
   VERSION_TIMESTAMP_PATTERN,
   formatVersionTimestamp,
   parseVersionTimestamp
 } from "../chunk-OPO5K4DZ.js";
 export {
+  DATA_BACKUP_PREFIX,
   DocumentVersionManager,
   VERSIONS_PREFIX,
   VERSION_TIMESTAMP_PATTERN,
+  buildDataBackupPath,
   buildVersionPath,
   coalesceVersions,
   formatVersionTimestamp,

package/dist/viewState-lTZS-hP_.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Table view state — the non-destructive sort/filter vocabulary that rides a
+ * `{[dataTable src=… sort=… filter=…]}` annotation. The data bytes are never
+ * touched; view state is part of the DOCUMENT (an author's sort shapes the
+ * bounded previews and exports), exactly like `sheet`/`anchor` are part of
+ * the reference.
+ *
+ * Grammar (inside the param value; the whole value then rides the ordinary
+ * `{[…]}` attr quoting):
+ *
+ *   sort   := term (',' term)*
+ *   term   := colName (':' ('asc'|'desc'))?          // default asc
+ *   filter := clause (';' clause)*                    // conjunction (AND) only
+ *   clause := colName op value
+ *   op     := textOp '*'? | cmpOp
+ *   textOp := '=' | '!=' | '~' | '!~' | '^~' | '$~'
+ *   cmpOp  := '>' | '<' | '>=' | '<='
+ *
+ * Text-matching ops (`= != ~ !~ ^~ $~`) are CASE-INSENSITIVE by default
+ * (Excel AutoFilter semantics); a `*` suffix makes the match case-sensitive
+ * (`Region=*West`). `~` is contains, `^~` starts-with, `$~` ends-with (the
+ * `~` marks the text family; `^`/`$` are the regex-anchor mnemonics).
+ * Comparison ops compare numerically on numeric columns and via the shared
+ * collator otherwise, and take no `*`. Column names address headers by exact
+ * text. Names/values containing structural characters are quoted CSV-style —
+ * double quotes with `""` doubling, NO backslashes (the outer `{[…]}` layer
+ * already owns backslash escaping inside quoted attr values; stacking a
+ * second backslash grammar inside would be unreadable and fragile):
+ *
+ *   sort=Revenue:desc,Region
+ *   sort="Ratio A:B":desc
+ *   filter=Region=West;Revenue>=1000
+ *   filter=Note~"a;b"
+ *
+ * Parsing NEVER throws: an unknown column drops that term/clause with a
+ * `data-view-unknown-column` issue; malformed syntax drops the whole param
+ * with `data-view-invalid`. Renderers fall back to natural order.
+ */
+interface SortTerm {
+    column: string;
+    dir: 'asc' | 'desc';
+}
+type FilterOp = '=' | '!=' | '>' | '<' | '>=' | '<=' | '~' | '!~' | '^~' | '$~';
+interface FilterClause {
+    column: string;
+    op: FilterOp;
+    value: string;
+    /**
+     * Case-sensitive matching for text ops (serialized as a `*` op suffix).
+     * Absent/false = the default case-insensitive match. Meaningless on the
+     * comparison ops and never serialized for them.
+     */
+    caseSensitive?: boolean;
+}
+interface TableViewState {
+    sort: SortTerm[];
+    filter: FilterClause[];
+}
+interface ViewIssue {
+    code: 'data-view-unknown-column' | 'data-view-invalid';
+    message: string;
+}
+interface ParsedTableViewState {
+    view: TableViewState;
+    issues: ViewIssue[];
+}
+declare const EMPTY_TABLE_VIEW_STATE: TableViewState;
+/** True when the view state changes nothing. */
+declare function isEmptyViewState(view: TableViewState): boolean;
+/**
+ * A column is numeric iff every non-blank trimmed cell parses to a finite
+ * number AND is not a leading-zero string (`"007"` stays text — zip codes,
+ * ids). Blank cells don't vote.
+ */
+declare function isNumericCellText(value: string): boolean;
+declare function inferNumericColumn(rows: readonly (readonly string[])[], col: number): boolean;
+/** The one collator both sides of the parity contract use. */
+declare function makeTableCollator(): Intl.Collator;
+declare function quoteViewToken(text: string): string;
+/**
+ * Parse the raw `sort`/`filter` param values against real headers.
+ * Never throws; degradation is per the module contract.
+ */
+declare function parseTableViewState(sortRaw: string | undefined, filterRaw: string | undefined, headers: readonly string[]): ParsedTableViewState;
+/** Serialize to `{ sort?, filter? }` raw param values (undefined = omit). */
+declare function serializeTableViewState(view: TableViewState): {
+    sort?: string;
+    filter?: string;
+};
+
+export { EMPTY_TABLE_VIEW_STATE as E, type FilterClause as F, type ParsedTableViewState as P, type SortTerm as S, type TableViewState as T, type ViewIssue as V, type FilterOp as a, isEmptyViewState as b, isNumericCellText as c, inferNumericColumn as i, makeTableCollator as m, parseTableViewState as p, quoteViewToken as q, serializeTableViewState as s };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Headless utilities for doc/block rendering, spatial math, Markdown, and storage",
   "license": "MIT",
   "author": "Bendyline",
@@ -131,6 +131,11 @@
       "types": "./dist/proof/index.d.ts",
       "import": "./dist/proof/index.js",
       "default": "./dist/proof/index.js"
+    },
+    "./table": {
+      "types": "./dist/table/index.d.ts",
+      "import": "./dist/table/index.js",
+      "default": "./dist/table/index.js"
     }
   },
   "scripts": {