@tensor_1/react 2.6.0 → 2.8.0

package/dist/table-engine.js

@@ -30,8 +30,36 @@ function toggleSort(keys, field, additive = false) {
 function asNum(v) {
   return typeof v === "number" ? v : Number(v);
 }
+function asTime(v) {
+  if (v == null) return NaN;
+  if (v instanceof Date) return v.getTime();
+  if (typeof v === "number") return v;
+  const s = String(v).trim();
+  if (s === "") return NaN;
+  const parsed = Date.parse(s);
+  return Number.isNaN(parsed) ? Number(s) : parsed;
+}
+function matchDate(cell, f) {
+  const c = asTime(cell);
+  if (Number.isNaN(c)) return false;
+  switch (f.op) {
+    case "eq":
+      return c === asTime(f.value);
+    case "lt":
+      return c < asTime(f.value);
+    case "gt":
+      return c > asTime(f.value);
+    case "between": {
+      const [lo, hi] = f.value.map(asTime);
+      return c >= lo && c <= hi;
+    }
+    default:
+      return true;
+  }
+}
 function matchFilter(row, f) {
   const cell = row[f.field];
+  if (f.kind === "date") return matchDate(cell, f);
   switch (f.op) {
     case "isAnyOf":
       return Array.isArray(f.value) && f.value.includes(cell);
@@ -90,13 +118,53 @@ function highlightSegments(text, query) {
   }
   return out;
 }
+const ARRAY_OPS = /* @__PURE__ */ new Set(["isAnyOf", "isNoneOf", "between"]);
+const escapePart = (s) => encodeURIComponent(s).replace(/~/g, "%7E");
+const unescapePart = (s) => decodeURIComponent(s);
+const scalarToStr = (v) => v == null ? "" : String(v);
+function parseScalar(s, kind) {
+  switch (kind) {
+    case "number":
+      return Number(s);
+    case "boolean":
+      return s === "true";
+    case "date":
+      return /^-?\d+$/.test(s) ? Number(s) : s;
+    // epoch-ms number, else the ISO/date string
+    default:
+      return s;
+  }
+}
+function kindFromOp(op) {
+  if (op === "isAnyOf" || op === "isNoneOf") return "enum";
+  if (op === "is") return "boolean";
+  if (op === "contains" || op === "equals" || op === "startsWith") return "text";
+  return "number";
+}
+function serializeFilter(f) {
+  const value = Array.isArray(f.value) ? f.value.map((x) => escapePart(scalarToStr(x))).join("|") : escapePart(scalarToStr(f.value));
+  return `${escapePart(f.field)}~${f.kind}~${f.op}~${value}`;
+}
+function parseFilter(tok) {
+  const parts = tok.split("~");
+  let field, kind, op, raw;
+  if (parts.length >= 4) {
+    [field, kind, op, raw] = [unescapePart(parts[0]), parts[1], parts[2], parts[3] ?? ""];
+  } else {
+    [field, op, raw] = [unescapePart(parts[0]), parts[1], parts[2] ?? ""];
+    kind = kindFromOp(op);
+  }
+  if (!field || !op) return null;
+  const value = ARRAY_OPS.has(op) ? raw.split("|").filter((s) => s !== "").map((s) => parseScalar(unescapePart(s), kind)) : parseScalar(unescapePart(raw), kind);
+  return { field, kind, op, value };
+}
 function serializeView(v) {
   const p = new URLSearchParams();
   if (v.sort?.length) p.set("sort", v.sort.map((s) => `${s.field}:${s.dir === "descending" ? "d" : "a"}`).join(","));
   if (v.columns?.length) p.set("cols", v.columns.join(","));
   if (v.density && v.density !== "standard") p.set("density", v.density);
   if (v.q) p.set("q", v.q);
-  if (v.filters?.length) p.set("filter", v.filters.map((f) => `${f.field}~${f.op}~${Array.isArray(f.value) ? f.value.join("|") : f.value ?? ""}`).join(","));
+  if (v.filters?.length) p.set("filter", v.filters.map(serializeFilter).join(","));
   return p.toString();
 }
 function parseView(qs) {
@@ -114,11 +182,9 @@ function parseView(qs) {
   const q = p.get("q");
   if (q) v.q = q;
   const filter = p.get("filter");
-  if (filter) v.filters = filter.split(",").filter(Boolean).map((tok) => {
-    const [field, op, raw] = tok.split("~");
-    const value = raw?.includes("|") ? raw.split("|") : raw;
-    return { field, kind: "text", op, value };
-  });
+  if (filter) {
+    v.filters = filter.split(",").filter(Boolean).map(parseFilter).filter((f) => f !== null);
+  }
   return v;
 }
 function virtualWindow(scrollTop, viewportH, rowH, count, overscan = 6) {

package/dist/tree-model.d.ts

@@ -0,0 +1,48 @@
+/**
+ * uix tree model — framework-agnostic, dependency-free tree flattening + keyboard nav.
+ *
+ * Pure functions (no DOM, no React): flatten a nested tree into the linear list of *visible*
+ * rows (respecting expansion) so it can be virtualized with the table engine's virtualWindow,
+ * and resolve a keyboard key into a navigation decision. Both the plain and the virtualized
+ * <Tree> render paths use these, so the two behave identically and keyboard nav works even for
+ * rows that are scrolled out of the virtual window (UIX-FIX-05). Unit-tested (tree-model.test.mjs).
+ */
+/** Minimal shape a node must have; the concrete node (label, icon, …) rides along as `T`. */
+interface TreeLike<T> {
+    id: string;
+    children?: T[];
+}
+interface FlatNode<T> {
+    node: T;
+    /** 1-based depth, for aria-level. */
+    level: number;
+    /** number of siblings at this level (this node's parent's child count), for aria-setsize. */
+    setsize: number;
+    /** 1-based index among those siblings, for aria-posinset. */
+    posinset: number;
+    hasChildren: boolean;
+    isExpanded: boolean;
+}
+/**
+ * Flatten a nested tree into the visible rows, in DOM/reading order. A node's children follow
+ * it immediately and are included only when the node is in `expanded`.
+ */
+declare function flattenTree<T extends TreeLike<T>>(nodes: readonly T[], expanded: ReadonlySet<string>, level?: number): FlatNode<T>[];
+/** A decision produced by a key press — any subset may be set. */
+interface TreeNavAction {
+    /** move focus (roving tabindex) to this node id. */
+    focusId?: string;
+    /** toggle this node's expansion. */
+    toggleId?: string;
+    /** select this node id. */
+    selectId?: string;
+}
+/**
+ * Resolve a key press against the flattened, visible node list — the single source of truth for
+ * both render paths. Mirrors the WAI-ARIA tree pattern: Up/Down move by row, Right expands then
+ * descends, Left collapses then ascends to the parent, Home/End jump, Enter/Space select (and
+ * toggle a parent). Returns an empty action for unhandled keys or an unknown current id.
+ */
+declare function treeNav<T extends TreeLike<T>>(flat: readonly FlatNode<T>[], currentId: string | undefined, key: string): TreeNavAction;
+
+export { type FlatNode, type TreeLike, type TreeNavAction, flattenTree, treeNav };

package/dist/tree-model.js

@@ -0,0 +1,49 @@
+function flattenTree(nodes, expanded, level = 1) {
+  const out = [];
+  const setsize = nodes.length;
+  nodes.forEach((node, i) => {
+    const hasChildren = Array.isArray(node.children) && node.children.length > 0;
+    const isExpanded = hasChildren && expanded.has(node.id);
+    out.push({ node, level, setsize, posinset: i + 1, hasChildren, isExpanded });
+    if (isExpanded) out.push(...flattenTree(node.children, expanded, level + 1));
+  });
+  return out;
+}
+function treeNav(flat, currentId, key) {
+  const idx = flat.findIndex((f) => f.node.id === currentId);
+  if (idx < 0) return {};
+  const cur = flat[idx];
+  const focusAt = (i) => {
+    const clamped = Math.max(0, Math.min(flat.length - 1, i));
+    return { focusId: flat[clamped]?.node.id };
+  };
+  switch (key) {
+    case "ArrowDown":
+      return focusAt(idx + 1);
+    case "ArrowUp":
+      return focusAt(idx - 1);
+    case "Home":
+      return focusAt(0);
+    case "End":
+      return focusAt(flat.length - 1);
+    case "ArrowRight":
+      if (cur.hasChildren && !cur.isExpanded) return { toggleId: cur.node.id };
+      if (cur.hasChildren && cur.isExpanded) return focusAt(idx + 1);
+      return {};
+    case "ArrowLeft":
+      if (cur.hasChildren && cur.isExpanded) return { toggleId: cur.node.id };
+      for (let i = idx - 1; i >= 0; i--) {
+        if (flat[i].level === cur.level - 1) return { focusId: flat[i].node.id };
+      }
+      return {};
+    case "Enter":
+    case " ":
+      return cur.hasChildren ? { toggleId: cur.node.id, selectId: cur.node.id } : { selectId: cur.node.id };
+    default:
+      return {};
+  }
+}
+export {
+  flattenTree,
+  treeNav
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor_1/react",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "Thin React wrappers over the UIx v2 CSS component library.",
   "license": "UNLICENSED",
   "type": "module",