@tensor_1/react 2.11.0 → 2.13.0

package/dist/index.js

@@ -1,6 +1,7 @@
 import { cx } from "./cx.js";
 import { useDialog } from "./hooks/useDialog.js";
 import { useTable } from "./hooks/useTable.js";
+import { useVirtualRows } from "./hooks/useVirtualRows.js";
 import { useAnchoredPosition } from "./hooks/useAnchoredPosition.js";
 import { computePosition } from "./overlay-position.js";
 import { Button, ButtonGroup } from "./components/Button.js";
@@ -78,11 +79,53 @@ import {
   EventRow,
   StatusRow
 } from "./components/EditorialHome.js";
+import { RuleBuilder } from "./components/RuleBuilder.js";
+import {
+  appendRuleNode,
+  findRuleNodeDepth,
+  isRuleGroup,
+  mapRuleGroup,
+  moveRuleNode,
+  removeRuleNode,
+  ruleDepth,
+  summarizeRule,
+  validateRuleDefinition
+} from "./rule-builder-model.js";
+import { BuilderCanvas } from "./components/BuilderCanvas.js";
+import { SchedulingCalendar } from "./components/SchedulingCalendar.js";
+import { DateRangePicker } from "./components/DateRangePicker.js";
+import {
+  addCalendarDays,
+  addCalendarMonths,
+  buildMonthGrid,
+  enumerateDateSpan,
+  isDateInRange,
+  isDateUnavailable,
+  selectRangeDate,
+  startOfMonth,
+  toDateKey,
+  zonedDateKey,
+  zonedDateSpan
+} from "./calendar-model.js";
+import { RelationshipGraph } from "./components/RelationshipGraph.js";
+import { boundRelationshipGraph, layoutRelationshipGraph, relationshipNeighbors, traverseRelationshipNode } from "./relationship-graph-model.js";
+import { MatchReview } from "./components/MatchReview.js";
+import { MetricInput } from "./components/MetricInput.js";
+import { clampMetricValue, parseMetricValue, stepMetricValue } from "./metric-model.js";
+import { LicensePositionBar } from "./components/LicensePositionBar.js";
+import { BrandProfiles, BrandProfileEditor, applyBrandProfile, restoreBrandProfile } from "./components/BrandProfiles.js";
+import { DiffViewer } from "./components/DiffViewer.js";
+import { buildThreeWayDiff, summarizeDiff } from "./diff-model.js";
+import { ColorPicker } from "./components/ColorPicker.js";
+import { contrastRatio, hexToRgb, hsvToHex, hsvToRgb, meetsContrast, normalizeHex, rgbToHex, rgbToHsv } from "./color-model.js";
 export {
   Alert,
   AppShell,
   Avatar,
   AvatarGroup,
+  BrandProfileEditor,
+  BrandProfiles,
+  BuilderCanvas,
   BulkBar,
   Button,
   ButtonGroup,
@@ -90,6 +133,7 @@ export {
   CellStrong,
   CellSub,
   Checkbox,
+  ColorPicker,
   CommandGroup,
   CommandItem,
   CommandPalette,
@@ -99,9 +143,11 @@ export {
   ComposerBar,
   ContentList,
   ContentListItem,
+  DateRangePicker,
   DescriptionItem,
   DescriptionList,
   DetailLayout,
+  DiffViewer,
   Drawer,
   EmptyState,
   ErrorState,
@@ -122,11 +168,14 @@ export {
   KanbanCard,
   KanbanColumn,
   Label,
+  LicensePositionBar,
   List,
   ListItem,
   LoadingState,
   Mark,
+  MatchReview,
   Meter,
+  MetricInput,
   Modal,
   NavFavourites,
   NavGroup,
@@ -143,9 +192,12 @@ export {
   Prose,
   Radio,
   RadioGroup,
+  RelationshipGraph,
   ResourceGrid,
   RowAction,
   RowActions,
+  RuleBuilder,
+  SchedulingCalendar,
   SectionHead,
   Segmented,
   SegmentedOption,
@@ -176,11 +228,51 @@ export {
   Tr,
   Tree,
   UserChip,
+  addCalendarDays,
+  addCalendarMonths,
+  appendRuleNode,
+  applyBrandProfile,
+  boundRelationshipGraph,
+  buildMonthGrid,
+  buildThreeWayDiff,
+  clampMetricValue,
   computePosition,
+  contrastRatio,
   cx,
+  enumerateDateSpan,
+  findRuleNodeDepth,
   flattenTree,
+  hexToRgb,
+  hsvToHex,
+  hsvToRgb,
+  isDateInRange,
+  isDateUnavailable,
+  isRuleGroup,
+  layoutRelationshipGraph,
+  mapRuleGroup,
+  meetsContrast,
+  moveRuleNode,
+  normalizeHex,
+  parseMetricValue,
+  relationshipNeighbors,
+  removeRuleNode,
+  restoreBrandProfile,
+  rgbToHex,
+  rgbToHsv,
+  ruleDepth,
+  selectRangeDate,
+  startOfMonth,
+  stepMetricValue,
+  summarizeDiff,
+  summarizeRule,
+  toDateKey,
+  traverseRelationshipNode,
   treeNav,
   useAnchoredPosition,
   useDialog,
-  useTable
+  useTable,
+  useVirtualRows,
+  validateRuleDefinition,
+  zonedDateKey,
+  zonedDateSpan
 };

package/dist/json-value.d.ts

@@ -0,0 +1,10 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+declare function isJsonObject(value: JsonValue | undefined): value is {
+    [key: string]: JsonValue;
+};
+declare function jsonEqual(a: JsonValue | undefined, b: JsonValue | undefined): boolean;
+
+export { type JsonPrimitive, type JsonValue, isJsonObject, jsonEqual };

package/dist/json-value.js

@@ -0,0 +1,19 @@
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function jsonEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((value, index) => jsonEqual(value, b[index]));
+  }
+  if (isJsonObject(a) && isJsonObject(b)) {
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && jsonEqual(a[key], b[key]));
+  }
+  return false;
+}
+export {
+  isJsonObject,
+  jsonEqual
+};

package/dist/metric-model.d.ts

@@ -0,0 +1,9 @@
+declare function clampMetricValue(value: number, min?: number, max?: number): number;
+declare function stepMetricValue(value: number | null, direction: -1 | 1, options?: {
+    min?: number;
+    max?: number;
+    step?: number;
+}): number;
+declare function parseMetricValue(value: string): number | null;
+
+export { clampMetricValue, parseMetricValue, stepMetricValue };

package/dist/metric-model.js

@@ -0,0 +1,25 @@
+function decimals(value) {
+  const text = String(value).toLowerCase();
+  if (text.includes("e-")) return Number(text.split("e-")[1]);
+  return text.includes(".") ? text.split(".")[1].length : 0;
+}
+function clampMetricValue(value, min, max) {
+  return Math.min(max ?? Number.POSITIVE_INFINITY, Math.max(min ?? Number.NEGATIVE_INFINITY, value));
+}
+function stepMetricValue(value, direction, options = {}) {
+  const step = options.step && options.step > 0 ? options.step : 1;
+  const base = value ?? options.min ?? 0;
+  const precision = Math.max(decimals(base), decimals(step), decimals(options.min ?? 0), decimals(options.max ?? 0));
+  const next = Number((base + direction * step).toFixed(precision));
+  return clampMetricValue(next, options.min, options.max);
+}
+function parseMetricValue(value) {
+  if (value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+export {
+  clampMetricValue,
+  parseMetricValue,
+  stepMetricValue
+};

package/dist/relationship-graph-model.d.ts

@@ -0,0 +1,31 @@
+interface RelationshipGraphNode {
+    id: string;
+    label: string;
+    type?: string;
+    description?: string;
+    x?: number;
+    y?: number;
+}
+interface RelationshipGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type?: string;
+    label?: string;
+}
+interface PositionedRelationshipNode extends RelationshipGraphNode {
+    x: number;
+    y: number;
+    depth: number;
+}
+interface BoundedRelationshipGraph {
+    nodes: RelationshipGraphNode[];
+    edges: RelationshipGraphEdge[];
+    omittedNodeCount: number;
+}
+declare function boundRelationshipGraph(nodes: RelationshipGraphNode[], edges: RelationshipGraphEdge[], maxNodes?: number): BoundedRelationshipGraph;
+declare function relationshipNeighbors(nodeId: string, edges: RelationshipGraphEdge[]): string[];
+declare function layoutRelationshipGraph(nodes: RelationshipGraphNode[], edges: RelationshipGraphEdge[], rootId?: string): PositionedRelationshipNode[];
+declare function traverseRelationshipNode(nodes: RelationshipGraphNode[], currentId: string | undefined, direction: -1 | 1): string | undefined;
+
+export { type BoundedRelationshipGraph, type PositionedRelationshipNode, type RelationshipGraphEdge, type RelationshipGraphNode, boundRelationshipGraph, layoutRelationshipGraph, relationshipNeighbors, traverseRelationshipNode };

package/dist/relationship-graph-model.js

@@ -0,0 +1,68 @@
+function boundRelationshipGraph(nodes, edges, maxNodes = 40) {
+  const boundedNodes = nodes.slice(0, Math.max(1, maxNodes));
+  const ids = new Set(boundedNodes.map((node) => node.id));
+  return {
+    nodes: boundedNodes,
+    edges: edges.filter((edge) => ids.has(edge.source) && ids.has(edge.target)),
+    omittedNodeCount: Math.max(0, nodes.length - boundedNodes.length)
+  };
+}
+function relationshipNeighbors(nodeId, edges) {
+  const result = [];
+  for (const edge of edges) {
+    if (edge.source === nodeId) result.push(edge.target);
+    else if (edge.target === nodeId) result.push(edge.source);
+  }
+  return [...new Set(result)];
+}
+function layoutRelationshipGraph(nodes, edges, rootId = nodes[0]?.id) {
+  if (nodes.length === 0) return [];
+  const root = nodes.some((node) => node.id === rootId) ? rootId : nodes[0].id;
+  const depth = /* @__PURE__ */ new Map([[root, 0]]);
+  const queue = [root];
+  while (queue.length) {
+    const current = queue.shift();
+    for (const neighbor of relationshipNeighbors(current, edges)) {
+      if (!depth.has(neighbor) && nodes.some((node) => node.id === neighbor)) {
+        depth.set(neighbor, (depth.get(current) ?? 0) + 1);
+        queue.push(neighbor);
+      }
+    }
+  }
+  let disconnectedDepth = Math.max(0, ...depth.values()) + 1;
+  nodes.forEach((node) => {
+    if (!depth.has(node.id)) depth.set(node.id, disconnectedDepth);
+  });
+  const groups = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    const level = depth.get(node.id);
+    groups.set(level, [...groups.get(level) ?? [], node]);
+  });
+  const maxDepth = Math.max(1, ...groups.keys());
+  return nodes.map((node) => {
+    const level = depth.get(node.id);
+    if (node.x !== void 0 && node.y !== void 0) return { ...node, x: node.x, y: node.y, depth: level };
+    if (level === 0) return { ...node, x: 50, y: 50, depth: 0 };
+    const peers = groups.get(level);
+    const index = peers.findIndex((peer) => peer.id === node.id);
+    const angle = Math.PI * 2 * index / peers.length - Math.PI / 2;
+    const radius = 16 + level / maxDepth * 26;
+    return {
+      ...node,
+      x: Number((50 + Math.cos(angle) * radius).toFixed(3)),
+      y: Number((50 + Math.sin(angle) * radius).toFixed(3)),
+      depth: level
+    };
+  });
+}
+function traverseRelationshipNode(nodes, currentId, direction) {
+  if (nodes.length === 0) return void 0;
+  const current = Math.max(0, nodes.findIndex((node) => node.id === currentId));
+  return nodes[(current + direction + nodes.length) % nodes.length]?.id;
+}
+export {
+  boundRelationshipGraph,
+  layoutRelationshipGraph,
+  relationshipNeighbors,
+  traverseRelationshipNode
+};

package/dist/rule-builder-model.d.ts

@@ -0,0 +1,41 @@
+import { JsonValue } from './json-value.js';
+
+interface RuleCondition {
+    id: string;
+    field: string;
+    operator: string;
+    value?: JsonValue;
+}
+interface RuleGroup {
+    id: string;
+    combinator: 'and' | 'or';
+    conditions: Array<RuleCondition | RuleGroup>;
+}
+interface RuleAction {
+    id: string;
+    type: string;
+    parameters: Record<string, JsonValue>;
+}
+interface RuleDefinition {
+    when: RuleGroup;
+    then: RuleAction[];
+}
+interface RuleValidationIssue {
+    path: string;
+    message: string;
+}
+declare function isRuleGroup(node: RuleCondition | RuleGroup): node is RuleGroup;
+declare function ruleDepth(group: RuleGroup): number;
+declare function findRuleNodeDepth(group: RuleGroup, id: string, depth?: number): number | undefined;
+declare function mapRuleGroup(group: RuleGroup, id: string, update: (node: RuleCondition | RuleGroup) => RuleCondition | RuleGroup): RuleGroup;
+declare function appendRuleNode(group: RuleGroup, parentId: string, node: RuleCondition | RuleGroup, maxDepth?: number): RuleGroup;
+declare function removeRuleNode(group: RuleGroup, id: string): RuleGroup;
+declare function moveRuleNode(group: RuleGroup, id: string, direction: -1 | 1): RuleGroup;
+declare function validateRuleDefinition(value: RuleDefinition, maxDepth?: number): RuleValidationIssue[];
+declare function summarizeRule(value: RuleDefinition, labels?: {
+    fields?: Record<string, string>;
+    operators?: Record<string, string>;
+    actions?: Record<string, string>;
+}): string;
+
+export { type RuleAction, type RuleCondition, type RuleDefinition, type RuleGroup, type RuleValidationIssue, appendRuleNode, findRuleNodeDepth, isRuleGroup, mapRuleGroup, moveRuleNode, removeRuleNode, ruleDepth, summarizeRule, validateRuleDefinition };

package/dist/rule-builder-model.js

@@ -0,0 +1,101 @@
+function isRuleGroup(node) {
+  return "conditions" in node;
+}
+function ruleDepth(group) {
+  return 1 + Math.max(0, ...group.conditions.filter(isRuleGroup).map(ruleDepth));
+}
+function findRuleNodeDepth(group, id, depth = 1) {
+  if (group.id === id) return depth;
+  for (const node of group.conditions) {
+    if (node.id === id) return depth + 1;
+    if (isRuleGroup(node)) {
+      const found = findRuleNodeDepth(node, id, depth + 1);
+      if (found !== void 0) return found;
+    }
+  }
+  return void 0;
+}
+function mapRuleGroup(group, id, update) {
+  if (group.id === id) return update(group);
+  return {
+    ...group,
+    conditions: group.conditions.map((node) => {
+      if (node.id === id) return update(node);
+      return isRuleGroup(node) ? mapRuleGroup(node, id, update) : node;
+    })
+  };
+}
+function appendRuleNode(group, parentId, node, maxDepth = 3) {
+  const parentDepth = findRuleNodeDepth(group, parentId);
+  if (parentDepth === void 0) return group;
+  const addedDepth = isRuleGroup(node) ? ruleDepth(node) : 0;
+  if (parentDepth + addedDepth > maxDepth) return group;
+  return mapRuleGroup(group, parentId, (parent) => isRuleGroup(parent) ? { ...parent, conditions: [...parent.conditions, node] } : parent);
+}
+function removeRuleNode(group, id) {
+  return {
+    ...group,
+    conditions: group.conditions.filter((node) => node.id !== id).map((node) => isRuleGroup(node) ? removeRuleNode(node, id) : node)
+  };
+}
+function moveRuleNode(group, id, direction) {
+  const index = group.conditions.findIndex((node) => node.id === id);
+  if (index >= 0) {
+    const target = index + direction;
+    if (target < 0 || target >= group.conditions.length) return group;
+    const conditions = [...group.conditions];
+    [conditions[index], conditions[target]] = [conditions[target], conditions[index]];
+    return { ...group, conditions };
+  }
+  return {
+    ...group,
+    conditions: group.conditions.map((node) => isRuleGroup(node) ? moveRuleNode(node, id, direction) : node)
+  };
+}
+function validateRuleDefinition(value, maxDepth = 3) {
+  const issues = [];
+  const ids = /* @__PURE__ */ new Set();
+  const visit = (group, path, depth) => {
+    if (ids.has(group.id)) issues.push({ path, message: `Duplicate id \u201C${group.id}\u201D.` });
+    ids.add(group.id);
+    if (depth > maxDepth) issues.push({ path, message: `Nesting exceeds ${maxDepth} levels.` });
+    if (group.conditions.length === 0) issues.push({ path, message: "Add at least one condition." });
+    group.conditions.forEach((node, index) => {
+      const nodePath = `${path}.conditions[${index}]`;
+      if (ids.has(node.id)) issues.push({ path: nodePath, message: `Duplicate id \u201C${node.id}\u201D.` });
+      if (isRuleGroup(node)) visit(node, nodePath, depth + 1);
+      else {
+        ids.add(node.id);
+        if (!node.field) issues.push({ path: nodePath, message: "Choose a field." });
+        if (!node.operator) issues.push({ path: nodePath, message: "Choose an operator." });
+      }
+    });
+  };
+  visit(value.when, "when", 1);
+  if (value.then.length === 0) issues.push({ path: "then", message: "Add at least one action." });
+  value.then.forEach((action, index) => {
+    if (ids.has(action.id)) issues.push({ path: `then[${index}]`, message: `Duplicate id \u201C${action.id}\u201D.` });
+    ids.add(action.id);
+    if (!action.type) issues.push({ path: `then[${index}]`, message: "Choose an action." });
+  });
+  return issues;
+}
+function summarizeRule(value, labels = {}) {
+  const formatValue = (input) => input === void 0 ? "" : ` ${JSON.stringify(input)}`;
+  const formatGroup = (group) => group.conditions.map(
+    (node) => isRuleGroup(node) ? `(${formatGroup(node)})` : `${labels.fields?.[node.field] ?? node.field} ${labels.operators?.[node.operator] ?? node.operator}${formatValue(node.value)}`
+  ).join(` ${group.combinator.toUpperCase()} `);
+  const actions = value.then.map((action) => labels.actions?.[action.type] ?? action.type).join(", ");
+  return `When ${formatGroup(value.when) || "no conditions"}, then ${actions || "no actions"}.`;
+}
+export {
+  appendRuleNode,
+  findRuleNodeDepth,
+  isRuleGroup,
+  mapRuleGroup,
+  moveRuleNode,
+  removeRuleNode,
+  ruleDepth,
+  summarizeRule,
+  validateRuleDefinition
+};

package/dist/table-engine.js

@@ -1,19 +1,20 @@
+const stringCollator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
 function compare(a, b) {
   if (a == null && b == null) return 0;
   if (a == null) return -1;
   if (b == null) return 1;
   if (typeof a === "number" && typeof b === "number") return a - b;
-  return String(a).localeCompare(String(b), void 0, { numeric: true, sensitivity: "base" });
+  return stringCollator.compare(String(a), String(b));
 }
 function multiSort(rows, keys) {
   if (!keys.length) return rows.slice();
-  return rows.map((row, i) => ({ row, i })).sort((x, y) => {
+  return rows.slice().sort((a, b) => {
     for (const k of keys) {
-      const c = compare(x.row[k.field], y.row[k.field]);
+      const c = compare(a[k.field], b[k.field]);
       if (c !== 0) return k.dir === "ascending" ? c : -c;
     }
-    return x.i - y.i;
-  }).map((w) => w.row);
+    return 0;
+  });
 }
 function nextSortDir(current) {
   if (current === "ascending") return "descending";
@@ -213,7 +214,8 @@ function toggleId(set, id) {
   return next;
 }
 function selectAllState(selected, pageIds) {
-  const on = pageIds.filter((id) => selected.has(id)).length;
+  let on = 0;
+  for (const id of pageIds) if (selected.has(id)) on += 1;
   if (on === 0) return "none";
   return on === pageIds.length ? "all" : "some";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor_1/react",
-  "version": "2.11.0",
+  "version": "2.13.0",
   "description": "Thin React wrappers over the UIx v2 CSS component library.",
   "license": "UNLICENSED",
   "type": "module",
@@ -26,22 +26,36 @@
       "types": "./dist/chart.d.ts",
       "import": "./dist/chart.js",
       "require": "./dist/chart.cjs"
+    },
+    "./chart/preset": {
+      "types": "./dist/chart-preset.d.ts",
+      "import": "./dist/chart-preset.js",
+      "require": "./dist/chart-preset.cjs"
     }
   },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
-    "test": "node --test"
+    "test": "node --test",
+    "test:performance": "node scripts/table-performance.mjs",
+    "size": "node scripts/check-chart-preset-size.mjs"
   },
   "peerDependencies": {
+    "echarts": "^5.6.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
+  "peerDependenciesMeta": {
+    "echarts": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/react": "^18.0.0",
     "@types/react-dom": "^18.0.0",
     "echarts": "^5.6.0",
+    "esbuild": "^0.27.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   }