@tensor_1/react 2.12.0 → 2.13.0

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/package.json

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