@tensor_1/react 2.12.0 → 2.13.0

package/dist/components/MetricInput.d.ts

@@ -0,0 +1,23 @@
+import * as react from 'react';
+
+interface MetricInputProps {
+    value: number | null;
+    onValueChange: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    label: string;
+    invalid?: boolean;
+    errorMessage?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    parse?: (input: string) => number | null;
+    format?: (value: number | null) => string;
+    className?: string;
+    id?: string;
+}
+/** Accessible numeric recipe composed from Input and the UIx stepper controls. */
+declare function MetricInput({ value, onValueChange, min, max, step, unit, label, invalid, errorMessage, disabled, readOnly, parse, format, className, id: providedId, }: MetricInputProps): react.JSX.Element;
+
+export { MetricInput, type MetricInputProps };

package/dist/components/MetricInput.js

@@ -0,0 +1,92 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useState } from "react";
+import { cx } from "../cx.js";
+import { clampMetricValue, parseMetricValue, stepMetricValue } from "../metric-model.js";
+import { Input } from "./Input.js";
+const defaultMetricFormat = (input) => input == null ? "" : String(input);
+function MetricInput({
+  value,
+  onValueChange,
+  min,
+  max,
+  step = 1,
+  unit,
+  label,
+  invalid,
+  errorMessage,
+  disabled,
+  readOnly,
+  parse = parseMetricValue,
+  format = defaultMetricFormat,
+  className,
+  id: providedId
+}) {
+  const generatedId = useId();
+  const id = providedId ?? generatedId;
+  const errorId = `${id}-error`;
+  const [text, setText] = useState(() => format(value));
+  useEffect(() => setText(format(value)), [value, format]);
+  const commit = (input) => {
+    const parsed = parse(input);
+    if (input.trim() === "" || parsed !== null) {
+      onValueChange(parsed === null ? null : clampMetricValue(parsed, min, max));
+    }
+  };
+  const stepBy = (direction) => {
+    const next = stepMetricValue(value, direction, { min, max, step });
+    onValueChange(next);
+    setText(format(next));
+  };
+  const onKeyDown = (event) => {
+    if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+      event.preventDefault();
+      stepBy(event.key === "ArrowUp" ? 1 : -1);
+    }
+  };
+  const onChange = (event) => {
+    setText(event.currentTarget.value);
+    commit(event.currentTarget.value);
+  };
+  const onBlur = (event) => {
+    const parsed = parse(event.currentTarget.value);
+    setText(parsed === null && event.currentTarget.value.trim() !== "" ? format(value) : format(parsed));
+  };
+  return /* @__PURE__ */ jsxs("div", { className: cx("uix-metric-input", invalid && "uix-metric-input--invalid", className), children: [
+    /* @__PURE__ */ jsx("label", { className: "uix-field__label", htmlFor: id, children: label }),
+    /* @__PURE__ */ jsxs("div", { className: "uix-metric-input__control", children: [
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          id,
+          value: text,
+          onChange,
+          onBlur,
+          onKeyDown,
+          inputMode: "decimal",
+          role: "spinbutton",
+          "aria-valuenow": value ?? void 0,
+          "aria-valuemin": min,
+          "aria-valuemax": max,
+          "aria-describedby": invalid && errorMessage ? errorId : void 0,
+          invalid,
+          disabled,
+          readOnly
+        }
+      ),
+      unit && /* @__PURE__ */ jsx("span", { className: "uix-metric-input__unit", "aria-hidden": "true", children: unit }),
+      /* @__PURE__ */ jsxs("span", { className: "uix-metric-input__steps", children: [
+        /* @__PURE__ */ jsx("button", { type: "button", className: "uix-metric-input__step", onClick: () => stepBy(1), disabled: disabled || readOnly, "aria-label": `Increase ${label}`, children: "+" }),
+        /* @__PURE__ */ jsx("button", { type: "button", className: "uix-metric-input__step", onClick: () => stepBy(-1), disabled: disabled || readOnly, "aria-label": `Decrease ${label}`, children: "\u2212" })
+      ] })
+    ] }),
+    unit && /* @__PURE__ */ jsxs("span", { className: "uix-visually-hidden", children: [
+      "Unit: ",
+      unit
+    ] }),
+    invalid && errorMessage && /* @__PURE__ */ jsx("span", { id: errorId, className: "uix-field__error", children: errorMessage })
+  ] });
+}
+export {
+  MetricInput
+};

package/dist/components/RelationshipGraph.d.ts

@@ -0,0 +1,30 @@
+import * as react from 'react';
+import { RelationshipGraphNode, RelationshipGraphEdge } from '../relationship-graph-model.js';
+
+interface RelationshipGraphLegendItem {
+    id: string;
+    label: string;
+}
+interface RelationshipGraphProps {
+    nodes: RelationshipGraphNode[];
+    edges: RelationshipGraphEdge[];
+    selectedId?: string;
+    onSelect?: (node: RelationshipGraphNode) => void;
+    onExpandNeighbors?: (node: RelationshipGraphNode) => void;
+    onOpenDetails?: (node: RelationshipGraphNode) => void;
+    maxNodes?: number;
+    density?: 'compact' | 'standard';
+    highlightedNodeIds?: ReadonlySet<string>;
+    conflictedNodeIds?: ReadonlySet<string>;
+    highlightedEdgeIds?: ReadonlySet<string>;
+    conflictedEdgeIds?: ReadonlySet<string>;
+    legend?: RelationshipGraphLegendItem[];
+    loading?: boolean;
+    error?: string;
+    onRetry?: () => void;
+    className?: string;
+}
+/** Bounded, deterministic SVG relationship view with an equivalent accessible list. */
+declare function RelationshipGraph({ nodes, edges, selectedId, onSelect, onExpandNeighbors, onOpenDetails, maxNodes, density, highlightedNodeIds, conflictedNodeIds, highlightedEdgeIds, conflictedEdgeIds, legend, loading, error, onRetry, className, }: RelationshipGraphProps): react.JSX.Element;
+
+export { RelationshipGraph, type RelationshipGraphLegendItem, type RelationshipGraphProps };

package/dist/components/RelationshipGraph.js

@@ -0,0 +1,138 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useRef, useState } from "react";
+import { boundRelationshipGraph, layoutRelationshipGraph, relationshipNeighbors, traverseRelationshipNode } from "../relationship-graph-model.js";
+import { cx } from "../cx.js";
+const EMPTY_IDS = /* @__PURE__ */ new Set();
+const EMPTY_LEGEND = [];
+function RelationshipGraph({
+  nodes,
+  edges,
+  selectedId,
+  onSelect,
+  onExpandNeighbors,
+  onOpenDetails,
+  maxNodes = 40,
+  density = "standard",
+  highlightedNodeIds = EMPTY_IDS,
+  conflictedNodeIds = EMPTY_IDS,
+  highlightedEdgeIds = EMPTY_IDS,
+  conflictedEdgeIds = EMPTY_IDS,
+  legend = EMPTY_LEGEND,
+  loading,
+  error,
+  onRetry,
+  className
+}) {
+  const bounded = useMemo(() => boundRelationshipGraph(nodes, edges, maxNodes), [nodes, edges, maxNodes]);
+  const positioned = useMemo(() => layoutRelationshipGraph(bounded.nodes, bounded.edges, selectedId), [bounded, selectedId]);
+  const positionedById = useMemo(() => new Map(positioned.map((node) => [node.id, node])), [positioned]);
+  const [zoom, setZoom] = useState(1);
+  const [pan, setPan] = useState({ x: 0, y: 0 });
+  const [focusedId, setFocusedId] = useState(selectedId ?? positioned[0]?.id);
+  const svgRef = useRef(null);
+  const select = (id) => {
+    const node = bounded.nodes.find((item) => item.id === id);
+    if (node) onSelect?.(node);
+  };
+  const focusNode = (id) => {
+    if (!id) return;
+    setFocusedId(id);
+    requestAnimationFrame(() => svgRef.current?.querySelector(`[data-node-id="${id}"]`)?.focus());
+  };
+  const onNodeKeyDown = (event, id) => {
+    if (["ArrowRight", "ArrowDown", "ArrowLeft", "ArrowUp"].includes(event.key)) {
+      event.preventDefault();
+      focusNode(traverseRelationshipNode(positioned, id, event.key === "ArrowRight" || event.key === "ArrowDown" ? 1 : -1));
+    } else if (event.key === "Enter" || event.key === " ") {
+      event.preventDefault();
+      select(id);
+    }
+  };
+  const reset = () => {
+    setZoom(1);
+    setPan({ x: 0, y: 0 });
+  };
+  if (loading) return /* @__PURE__ */ jsx("div", { className: cx("uix-relationship-graph uix-relationship-graph--state", className), role: "status", children: "Loading relationships\u2026" });
+  if (error) return /* @__PURE__ */ jsxs("div", { className: cx("uix-relationship-graph uix-relationship-graph--state", className), role: "alert", children: [
+    /* @__PURE__ */ jsx("p", { children: error }),
+    onRetry && /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary", onClick: onRetry, children: "Try again" })
+  ] });
+  if (bounded.nodes.length === 0) return /* @__PURE__ */ jsxs("div", { className: cx("uix-relationship-graph uix-relationship-graph--state", className), children: [
+    /* @__PURE__ */ jsx("p", { children: "No relationships to display." }),
+    /* @__PURE__ */ jsx("p", { children: "Adjust the neighborhood or filters to include a node." })
+  ] });
+  return /* @__PURE__ */ jsxs("section", { className: cx("uix-relationship-graph", `uix-relationship-graph--${density}`, className), "aria-label": "Relationship graph", children: [
+    /* @__PURE__ */ jsxs("div", { className: "uix-relationship-graph__toolbar", "aria-label": "Graph view controls", children: [
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setPan((value) => ({ ...value, x: value.x - 24 })), "aria-label": "Pan left", children: "Left" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setPan((value) => ({ ...value, y: value.y - 24 })), "aria-label": "Pan up", children: "Up" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setPan((value) => ({ ...value, y: value.y + 24 })), "aria-label": "Pan down", children: "Down" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setPan((value) => ({ ...value, x: value.x + 24 })), "aria-label": "Pan right", children: "Right" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setZoom((value) => Math.min(2, Number((value + 0.2).toFixed(1)))), "aria-label": "Zoom in", children: "Zoom in" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setZoom((value) => Math.max(0.5, Number((value - 0.2).toFixed(1)))), "aria-label": "Zoom out", children: "Zoom out" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: reset, children: "Reset view" }),
+      /* @__PURE__ */ jsxs("span", { "aria-live": "polite", children: [
+        "Zoom ",
+        Math.round(zoom * 100),
+        "%"
+      ] })
+    ] }),
+    bounded.omittedNodeCount > 0 && /* @__PURE__ */ jsxs("p", { className: "uix-relationship-graph__bounded", role: "status", children: [
+      "Showing ",
+      bounded.nodes.length,
+      " nodes; ",
+      bounded.omittedNodeCount,
+      " outside this bounded neighborhood."
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "uix-relationship-graph__visual", children: /* @__PURE__ */ jsx("svg", { ref: svgRef, viewBox: "0 0 600 400", role: "group", "aria-label": `Graph with ${bounded.nodes.length} nodes and ${bounded.edges.length} relationships`, children: /* @__PURE__ */ jsxs("g", { transform: `translate(${pan.x} ${pan.y}) scale(${zoom})`, children: [
+      bounded.edges.map((edge) => {
+        const source = positionedById.get(edge.source);
+        const target = positionedById.get(edge.target);
+        return /* @__PURE__ */ jsx("line", { x1: source.x * 6, y1: source.y * 4, x2: target.x * 6, y2: target.y * 4, className: "uix-relationship-graph__edge", "data-highlighted": highlightedEdgeIds.has(edge.id) || void 0, "data-conflicted": conflictedEdgeIds.has(edge.id) || void 0, children: /* @__PURE__ */ jsx("title", { children: edge.label ?? edge.type ?? "Relationship" }) }, edge.id);
+      }),
+      positioned.map((node) => /* @__PURE__ */ jsxs(
+        "g",
+        {
+          transform: `translate(${node.x * 6} ${node.y * 4})`,
+          role: "button",
+          "aria-label": `${node.label}${node.type ? `, ${node.type}` : ""}${conflictedNodeIds.has(node.id) ? ", conflict" : ""}`,
+          tabIndex: focusedId === node.id ? 0 : -1,
+          "data-node-id": node.id,
+          className: "uix-relationship-graph__node",
+          "data-selected": selectedId === node.id || void 0,
+          "data-highlighted": highlightedNodeIds.has(node.id) || void 0,
+          "data-conflicted": conflictedNodeIds.has(node.id) || void 0,
+          onFocus: () => setFocusedId(node.id),
+          onKeyDown: (event) => onNodeKeyDown(event, node.id),
+          onClick: () => select(node.id),
+          children: [
+            /* @__PURE__ */ jsx("rect", { x: "-55", y: "-18", width: "110", height: "36", rx: "8" }),
+            /* @__PURE__ */ jsx("text", { textAnchor: "middle", dominantBaseline: "middle", children: node.label.length > 16 ? `${node.label.slice(0, 15)}\u2026` : node.label })
+          ]
+        },
+        node.id
+      ))
+    ] }) }) }),
+    legend.length > 0 && /* @__PURE__ */ jsx("ul", { className: "uix-relationship-graph__legend", "aria-label": "Relationship types", children: legend.map((item) => /* @__PURE__ */ jsx("li", { "data-type": item.id, children: item.label }, item.id)) }),
+    /* @__PURE__ */ jsxs("div", { className: "uix-relationship-graph__list", role: "region", "aria-label": "Accessible relationship list", children: [
+      /* @__PURE__ */ jsx("h3", { children: "Relationship list" }),
+      /* @__PURE__ */ jsx("ul", { children: bounded.nodes.map((node) => {
+        const neighbors = relationshipNeighbors(node.id, bounded.edges).map((id) => bounded.nodes.find((item) => item.id === id)?.label ?? id);
+        return /* @__PURE__ */ jsxs("li", { "data-selected": selectedId === node.id || void 0, children: [
+          /* @__PURE__ */ jsxs("button", { type: "button", onClick: () => select(node.id), "aria-pressed": selectedId === node.id, children: [
+            /* @__PURE__ */ jsx("strong", { children: node.label }),
+            node.type && /* @__PURE__ */ jsx("span", { children: node.type }),
+            /* @__PURE__ */ jsx("span", { children: neighbors.length ? `Connected to ${neighbors.join(", ")}` : "No visible connections" })
+          ] }),
+          /* @__PURE__ */ jsxs("span", { className: "uix-relationship-graph__list-actions", children: [
+            onExpandNeighbors && /* @__PURE__ */ jsx("button", { type: "button", onClick: () => onExpandNeighbors(node), children: "Expand neighbors" }),
+            onOpenDetails && /* @__PURE__ */ jsx("button", { type: "button", onClick: () => onOpenDetails(node), children: "Open details" })
+          ] })
+        ] }, node.id);
+      }) })
+    ] })
+  ] });
+}
+export {
+  RelationshipGraph
+};

package/dist/components/RuleBuilder.d.ts

@@ -0,0 +1,45 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { JsonValue } from '../json-value.js';
+import { RuleAction, RuleDefinition, RuleCondition, RuleValidationIssue } from '../rule-builder-model.js';
+
+interface RuleValueEditorProps {
+    condition: RuleCondition;
+    onChange: (value: JsonValue | undefined) => void;
+    disabled?: boolean;
+}
+interface RuleFieldDefinition {
+    id: string;
+    label: string;
+    description?: string;
+    operators?: string[];
+    renderValueEditor?: (props: RuleValueEditorProps) => ReactNode;
+}
+interface RuleOperatorDefinition {
+    id: string;
+    label: string;
+    requiresValue?: boolean;
+}
+interface RuleActionDefinition {
+    id: string;
+    label: string;
+    renderParameters?: (action: RuleAction, onChange: (parameters: Record<string, JsonValue>) => void, disabled: boolean) => ReactNode;
+}
+interface RuleBuilderProps {
+    value: RuleDefinition;
+    onChange: (value: RuleDefinition) => void;
+    fields: RuleFieldDefinition[];
+    operators: RuleOperatorDefinition[];
+    actions: RuleActionDefinition[];
+    maxDepth?: number;
+    readOnly?: boolean;
+    validate?: (value: RuleDefinition) => RuleValidationIssue[];
+    className?: string;
+    addConditionLabel?: string;
+    addGroupLabel?: string;
+    addActionLabel?: string;
+}
+/** Declarative controlled when-conditions-to-actions editor with bounded nesting. */
+declare function RuleBuilder({ value, onChange, fields, operators, actions, maxDepth, readOnly, validate, className, addConditionLabel, addGroupLabel, addActionLabel, }: RuleBuilderProps): react.JSX.Element;
+
+export { type RuleActionDefinition, RuleBuilder, type RuleBuilderProps, type RuleFieldDefinition, type RuleOperatorDefinition, type RuleValueEditorProps };

package/dist/components/RuleBuilder.js

@@ -0,0 +1,163 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { cx } from "../cx.js";
+import {
+  appendRuleNode,
+  isRuleGroup,
+  mapRuleGroup,
+  moveRuleNode,
+  removeRuleNode,
+  summarizeRule,
+  validateRuleDefinition
+} from "../rule-builder-model.js";
+let ruleId = 0;
+const nextId = (prefix) => `${prefix}-${Date.now().toString(36)}-${(++ruleId).toString(36)}`;
+function defaultCondition(fields, operators) {
+  const field = fields[0];
+  const operator = operators.find((item) => field?.operators?.includes(item.id)) ?? operators[0];
+  return { id: nextId("condition"), field: field?.id ?? "", operator: operator?.id ?? "", value: "" };
+}
+function RuleGroupEditor({ group, depth, root, fields, operators, maxDepth, disabled, onRootChange, labels }) {
+  const updateNode = (id, update) => onRootChange(mapRuleGroup(root, id, update));
+  const addCondition = () => onRootChange(appendRuleNode(root, group.id, defaultCondition(fields, operators), maxDepth));
+  const addGroup = () => onRootChange(appendRuleNode(root, group.id, {
+    id: nextId("group"),
+    combinator: "and",
+    conditions: [defaultCondition(fields, operators)]
+  }, maxDepth));
+  return /* @__PURE__ */ jsxs("fieldset", { className: "uix-rule-builder__group", "data-depth": depth, children: [
+    /* @__PURE__ */ jsxs("legend", { className: "uix-rule-builder__group-heading", children: [
+      /* @__PURE__ */ jsx("span", { children: depth === 1 ? "When" : "Group" }),
+      /* @__PURE__ */ jsxs("label", { children: [
+        "Match",
+        /* @__PURE__ */ jsxs("select", { className: "uix-select uix-select--sm", value: group.combinator, disabled, onChange: (event) => updateNode(group.id, (node) => ({ ...node, combinator: event.currentTarget.value })), children: [
+          /* @__PURE__ */ jsx("option", { value: "and", children: "all (AND)" }),
+          /* @__PURE__ */ jsx("option", { value: "or", children: "any (OR)" })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "uix-rule-builder__rows", children: group.conditions.map((node, index) => isRuleGroup(node) ? /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__nested", children: [
+      /* @__PURE__ */ jsx(RuleGroupEditor, { ...{ group: node, depth: depth + 1, root, fields, operators, maxDepth, disabled, onRootChange, labels } }),
+      /* @__PURE__ */ jsx(RowControls, { label: "group", first: index === 0, last: index === group.conditions.length - 1, disabled, onUp: () => onRootChange(moveRuleNode(root, node.id, -1)), onDown: () => onRootChange(moveRuleNode(root, node.id, 1)), onRemove: () => onRootChange(removeRuleNode(root, node.id)) })
+    ] }, node.id) : /* @__PURE__ */ jsx(
+      ConditionRow,
+      {
+        condition: node,
+        fields,
+        operators,
+        disabled,
+        onChange: (condition) => updateNode(node.id, () => condition),
+        controls: /* @__PURE__ */ jsx(RowControls, { label: "condition", first: index === 0, last: index === group.conditions.length - 1, disabled, onUp: () => onRootChange(moveRuleNode(root, node.id, -1)), onDown: () => onRootChange(moveRuleNode(root, node.id, 1)), onRemove: () => onRootChange(removeRuleNode(root, node.id)) })
+      },
+      node.id
+    )) }),
+    /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__add", children: [
+      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary uix-btn--sm", onClick: addCondition, disabled: disabled || fields.length === 0 || operators.length === 0, children: labels.addCondition }),
+      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: addGroup, disabled: disabled || depth >= maxDepth, children: labels.addGroup })
+    ] })
+  ] });
+}
+function ConditionRow({ condition, fields, operators, disabled, onChange, controls }) {
+  const field = fields.find((item) => item.id === condition.field);
+  const availableOperators = field?.operators?.length ? operators.filter((item) => field.operators.includes(item.id)) : operators;
+  const operator = operators.find((item) => item.id === condition.operator);
+  const setField = (id) => {
+    const nextField = fields.find((item) => item.id === id);
+    const nextOperator = operators.find((item) => nextField?.operators?.includes(item.id)) ?? availableOperators[0] ?? operators[0];
+    onChange({ ...condition, field: id, operator: nextOperator?.id ?? "" });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__condition", children: [
+    /* @__PURE__ */ jsxs("label", { children: [
+      /* @__PURE__ */ jsx("span", { className: "uix-visually-hidden", children: "Field" }),
+      /* @__PURE__ */ jsx("select", { className: "uix-select", value: condition.field, onChange: (event) => setField(event.currentTarget.value), disabled, children: fields.map((item) => /* @__PURE__ */ jsx("option", { value: item.id, children: item.label }, item.id)) })
+    ] }),
+    /* @__PURE__ */ jsxs("label", { children: [
+      /* @__PURE__ */ jsx("span", { className: "uix-visually-hidden", children: "Operator" }),
+      /* @__PURE__ */ jsx("select", { className: "uix-select", value: condition.operator, onChange: (event) => onChange({ ...condition, operator: event.currentTarget.value }), disabled, children: availableOperators.map((item) => /* @__PURE__ */ jsx("option", { value: item.id, children: item.label }, item.id)) })
+    ] }),
+    operator?.requiresValue !== false && /* @__PURE__ */ jsx("div", { className: "uix-rule-builder__value", children: field?.renderValueEditor?.({ condition, onChange: (value) => onChange({ ...condition, value }), disabled }) ?? /* @__PURE__ */ jsx("input", { className: "uix-input", value: typeof condition.value === "string" || typeof condition.value === "number" ? condition.value : condition.value == null ? "" : JSON.stringify(condition.value), onChange: (event) => onChange({ ...condition, value: event.currentTarget.value }), disabled, "aria-label": `Value for ${field?.label ?? "condition"}` }) }),
+    controls
+  ] });
+}
+function RowControls({ label, first, last, disabled, onUp, onDown, onRemove }) {
+  return /* @__PURE__ */ jsxs("span", { className: "uix-rule-builder__row-actions", children: [
+    /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: onUp, disabled: disabled || first, "aria-label": `Move ${label} up`, children: "Up" }),
+    /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: onDown, disabled: disabled || last, "aria-label": `Move ${label} down`, children: "Down" }),
+    /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: onRemove, disabled, "aria-label": `Remove ${label}`, children: "Remove" })
+  ] });
+}
+function RuleBuilder({
+  value,
+  onChange,
+  fields,
+  operators,
+  actions,
+  maxDepth = 3,
+  readOnly = false,
+  validate,
+  className,
+  addConditionLabel = "Add condition",
+  addGroupLabel = "Add group",
+  addActionLabel = "Add action"
+}) {
+  const issues = [...validateRuleDefinition(value, maxDepth), ...validate?.(value) ?? []];
+  const fieldLabels = Object.fromEntries(fields.map((field) => [field.id, field.label]));
+  const operatorLabels = Object.fromEntries(operators.map((operator) => [operator.id, operator.label]));
+  const actionLabels = Object.fromEntries(actions.map((action) => [action.id, action.label]));
+  if (readOnly) return /* @__PURE__ */ jsxs("section", { className: cx("uix-rule-builder uix-rule-builder--summary", className), "aria-label": "Rule summary", children: [
+    /* @__PURE__ */ jsx("p", { children: summarizeRule(value, { fields: fieldLabels, operators: operatorLabels, actions: actionLabels }) }),
+    issues.length > 0 && /* @__PURE__ */ jsxs("p", { className: "uix-rule-builder__invalid", children: [
+      "Rule has ",
+      issues.length,
+      " validation issue",
+      issues.length === 1 ? "" : "s",
+      "."
+    ] })
+  ] });
+  const updateActions = (next) => onChange({ ...value, then: next });
+  return /* @__PURE__ */ jsxs("section", { className: cx("uix-rule-builder", className), "aria-label": "Rule builder", children: [
+    /* @__PURE__ */ jsx(RuleGroupEditor, { group: value.when, depth: 1, root: value.when, fields, operators, maxDepth, disabled: readOnly, onRootChange: (when) => onChange({ ...value, when }), labels: { addCondition: addConditionLabel, addGroup: addGroupLabel } }),
+    /* @__PURE__ */ jsxs("fieldset", { className: "uix-rule-builder__actions", children: [
+      /* @__PURE__ */ jsx("legend", { children: "Then" }),
+      value.then.map((action, index) => {
+        const definition = actions.find((item) => item.id === action.type);
+        return /* @__PURE__ */ jsxs("div", { className: "uix-rule-builder__action", children: [
+          /* @__PURE__ */ jsx("select", { className: "uix-select", value: action.type, onChange: (event) => updateActions(value.then.map((item) => item.id === action.id ? { ...item, type: event.currentTarget.value } : item)), "aria-label": "Action type", children: actions.map((item) => /* @__PURE__ */ jsx("option", { value: item.id, children: item.label }, item.id)) }),
+          definition?.renderParameters?.(action, (parameters) => updateActions(value.then.map((item) => item.id === action.id ? { ...item, parameters } : item)), false),
+          /* @__PURE__ */ jsx(
+            RowControls,
+            {
+              label: "action",
+              first: index === 0,
+              last: index === value.then.length - 1,
+              disabled: false,
+              onUp: () => {
+                const next = [...value.then];
+                [next[index - 1], next[index]] = [next[index], next[index - 1]];
+                updateActions(next);
+              },
+              onDown: () => {
+                const next = [...value.then];
+                [next[index + 1], next[index]] = [next[index], next[index + 1]];
+                updateActions(next);
+              },
+              onRemove: () => updateActions(value.then.filter((item) => item.id !== action.id))
+            }
+          )
+        ] }, action.id);
+      }),
+      /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary uix-btn--sm", disabled: actions.length === 0, onClick: () => updateActions([...value.then, { id: nextId("action"), type: actions[0]?.id ?? "", parameters: {} }]), children: addActionLabel })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "uix-rule-builder__validation", "aria-live": "polite", children: issues.length === 0 ? /* @__PURE__ */ jsx("span", { children: "Rule is valid." }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs("strong", { children: [
+        issues.length,
+        " validation issue",
+        issues.length === 1 ? "" : "s"
+      ] }),
+      /* @__PURE__ */ jsx("ul", { children: issues.map((issue, index) => /* @__PURE__ */ jsx("li", { children: issue.message }, `${issue.path}-${index}`)) })
+    ] }) })
+  ] });
+}
+export {
+  RuleBuilder
+};

package/dist/components/SchedulingCalendar.d.ts

@@ -0,0 +1,42 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+type SchedulingCalendarView = 'month' | 'week' | 'agenda';
+type SchedulingEntryState = 'scheduled' | 'conflicted' | 'in-progress' | 'blackout-violation';
+type SchedulingOverlayKind = 'maintenance' | 'blackout';
+interface SchedulingCalendarEntry {
+    id: string;
+    title: string;
+    start: string;
+    end: string;
+    state?: SchedulingEntryState;
+    meta?: string;
+}
+interface SchedulingCalendarOverlay {
+    id: string;
+    label: string;
+    start: string;
+    end: string;
+    kind: SchedulingOverlayKind;
+}
+interface SchedulingCalendarProps {
+    entries: SchedulingCalendarEntry[];
+    anchorDate: string;
+    timeZone: string;
+    view?: SchedulingCalendarView;
+    onViewChange?: (view: SchedulingCalendarView) => void;
+    onAnchorDateChange?: (date: string) => void;
+    onSelectEntry?: (entry: SchedulingCalendarEntry) => void;
+    overlays?: SchedulingCalendarOverlay[];
+    filter?: (entry: SchedulingCalendarEntry) => boolean;
+    renderEntry?: (entry: SchedulingCalendarEntry) => ReactNode;
+    locale?: string;
+    loading?: boolean;
+    error?: string;
+    onRetry?: () => void;
+    className?: string;
+}
+/** Month/week/agenda calendar for UTC ranges rendered in an explicit IANA time zone. */
+declare function SchedulingCalendar({ entries, anchorDate, timeZone, view: controlledView, onViewChange, onAnchorDateChange, onSelectEntry, overlays, filter, renderEntry, locale, loading, error, onRetry, className, }: SchedulingCalendarProps): react.JSX.Element;
+
+export { SchedulingCalendar, type SchedulingCalendarEntry, type SchedulingCalendarOverlay, type SchedulingCalendarProps, type SchedulingCalendarView, type SchedulingEntryState, type SchedulingOverlayKind };