@tensor_1/react 2.46.0 → 2.48.0

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

@@ -1,8 +1,15 @@
+/**
+ * A colour that a node or an edge shares with a legend item (HAR-1639). Colour is never the only
+ * signal: say the same thing in the node's text, the edge's `description` or its `variant`.
+ */
+type RelationshipGraphTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'accent';
 interface RelationshipGraphNode {
     id: string;
     label: string;
     type?: string;
     description?: string;
+    /** Layered layout: the node's border and edge mark take this tone (HAR-1639). */
+    tone?: RelationshipGraphTone;
     x?: number;
     y?: number;
     /** Layered layout: the node's column. Omitted → BFS distance from the root along source→target. */
@@ -20,6 +27,18 @@ interface RelationshipGraphEdge {
     arrow?: RelationshipGraphArrow;
     /** Layered layout: always draw this edge's label, whatever the label policy. */
     emphasis?: boolean;
+    /**
+     * `dashed` draws the line dashed, e.g. an expected relation that is missing (HAR-1639). Default
+     * `solid`; a lateral or cycle edge is dashed either way.
+     */
+    variant?: 'solid' | 'dashed';
+    /** The line and arrowhead take this tone (HAR-1639). */
+    tone?: RelationshipGraphTone;
+    /**
+     * Said to assistive technology with the relationship, on both nodes it joins, e.g. "expected,
+     * missing" (HAR-1639). The drawn line itself is decoration; the nodes carry the relationship.
+     */
+    description?: string;
 }
 interface PositionedRelationshipNode extends RelationshipGraphNode {
     x: number;
@@ -35,7 +54,12 @@ declare function boundRelationshipGraph(nodes: RelationshipGraphNode[], edges: R
 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;
-type LayeredEdgeKind = 'forward' | 'lateral' | 'cycle';
+/**
+ * `forward` steps one column right; `skip` goes right across more than one column; `lateral`
+ * stays in its column; `back` goes left without closing a loop; `cycle` goes left and closes one
+ * (HAR-1639: only a cycle is flagged as one, and only lateral and cycle edges are dashed).
+ */
+type LayeredEdgeKind = 'forward' | 'skip' | 'lateral' | 'back' | 'cycle';
 interface LayeredLayoutOptions {
     rootId?: string;
     /** Minimum sibling group size that collapses into a cluster. Default 6; 0 disables. */
@@ -70,7 +94,7 @@ interface LayeredItem {
     children: string[];
     /** Set on the first member of an expanded cluster: the group its collapse control belongs to. */
     expandedGroup?: RelationshipGraphCluster;
-    /** True when a lateral or cycle edge touches this node. */
+    /** True when a cycle edge touches this node (HAR-1639: no longer set by skip, lateral or back edges). */
     inCycle: boolean;
     /** Edges (any kind) touching this item. */
     degree: number;
@@ -87,6 +111,10 @@ interface RoutedEdge {
     label?: string;
     arrow: RelationshipGraphArrow;
     emphasis: boolean;
+    /** The first underlying edge's `variant`, `tone` and `description`. */
+    variant: 'solid' | 'dashed';
+    tone?: RelationshipGraphTone;
+    description?: string;
     path: string;
     labelX: number;
     labelY: number;
@@ -96,6 +124,17 @@ interface RoutedEdge {
     arrowAngle: number;
     /** Label policy `auto` shows this label without interaction. */
     autoLabel: boolean;
+    /**
+     * The label is said once by the target column's header (`LayeredColumn.edgeLabel`), so the
+     * edge itself never draws it under `edgeLabels="auto"` (HAR-1387: 197 of 200 labels on a
+     * 300-node map read "depends on").
+     */
+    columnLabel: boolean;
+    /**
+     * One of a busy node's forward edges, drawn as a bus: along a shared trunk in the column gap
+     * and a short stub into the target, so a fan-out reads as one line, not a black fan (HAR-1387).
+     */
+    bus: boolean;
     /** The label wrapped to fit the column gap (at most two lines). */
     labelLines: string[];
 }
@@ -104,6 +143,11 @@ interface LayeredColumn {
     x: number;
     /** Underlying nodes in the column, cluster members included. */
     count: number;
+    /**
+     * The relation most forward edges into this column share, when the column takes more than a
+     * few of them: the header says it once and those edges draw no label (HAR-1387).
+     */
+    edgeLabel?: string;
 }
 interface LayeredLayout {
     rootId: string | undefined;
@@ -135,8 +179,39 @@ declare function classifyLayeredEdges(nodes: RelationshipGraphNode[], edges: Rel
 declare function clusterIdFor(parentId: string, type: string | undefined, edgeType: string | undefined): string;
 /** Layered, clustered, crossing-reduced layout for `RelationshipGraph layout="layered"`. */
 declare function layoutLayeredGraph(nodes: RelationshipGraphNode[], edges: RelationshipGraphEdge[], options?: LayeredLayoutOptions): LayeredLayout;
+/** An edge label's box on the stage, for `separateEdgeLabels`. */
+interface EdgeLabelBox {
+    id: string;
+    /** Centre of the label. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Where a label is drawn after `separateEdgeLabels`, or that it is left out. */
+interface PlacedEdgeLabel {
+    x: number;
+    y: number;
+    hidden: boolean;
+}
+/** The box a wrapped edge label takes, from its lines (the meta type size, as `wrapEdgeLabel` assumes). */
+declare function edgeLabelSize(lines: readonly string[]): {
+    width: number;
+    height: number;
+};
+/**
+ * Moves edge labels apart where they would be drawn over each other (HAR-1639: two labels on top
+ * of each other in a dense layered column). Labels are taken top to bottom; one that overlaps a
+ * label already placed moves down just below it. A label that would have to move further than
+ * `maxShift` from its edge is left out instead (the relationship is still in the nodes'
+ * descriptions and in the list). Deterministic: the same boxes give the same placement.
+ */
+declare function separateEdgeLabels(boxes: readonly EdgeLabelBox[], options?: {
+    gap?: number;
+    maxShift?: number;
+}): Map<string, PlacedEdgeLabel>;
 type LayeredNavigationKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End';
 /** Keyboard traversal over a layered layout: ←/→ along forward edges, ↑/↓ within a column. */
 declare function layeredNeighbor(layout: LayeredLayout, currentId: string | undefined, key: LayeredNavigationKey): string | undefined;
 
-export { type BoundedRelationshipGraph, type LayeredColumn, type LayeredEdgeClassification, type LayeredEdgeKind, type LayeredItem, type LayeredLayout, type LayeredLayoutOptions, type LayeredNavigationKey, type PositionedRelationshipNode, type RelationshipGraphArrow, type RelationshipGraphCluster, type RelationshipGraphEdge, type RelationshipGraphNode, type RoutedEdge, boundRelationshipGraph, classifyLayeredEdges, clusterIdFor, layeredNeighbor, layoutLayeredGraph, layoutRelationshipGraph, relationshipNeighbors, traverseRelationshipNode, wrapEdgeLabel };
+export { type BoundedRelationshipGraph, type EdgeLabelBox, type LayeredColumn, type LayeredEdgeClassification, type LayeredEdgeKind, type LayeredItem, type LayeredLayout, type LayeredLayoutOptions, type LayeredNavigationKey, type PlacedEdgeLabel, type PositionedRelationshipNode, type RelationshipGraphArrow, type RelationshipGraphCluster, type RelationshipGraphEdge, type RelationshipGraphNode, type RelationshipGraphTone, type RoutedEdge, boundRelationshipGraph, classifyLayeredEdges, clusterIdFor, edgeLabelSize, layeredNeighbor, layoutLayeredGraph, layoutRelationshipGraph, relationshipNeighbors, separateEdgeLabels, traverseRelationshipNode, wrapEdgeLabel };

package/dist/relationship-graph-model.js

@@ -142,6 +142,8 @@ function classifyLayeredEdges(nodes, edges, rootId = nodes[0]?.id) {
       const list = forwardOut.get(edge.source);
       if (list) list.push(edge.target);
       else forwardOut.set(edge.source, [edge.target]);
+    } else if (to > from + 1) {
+      kindById.set(edge.id, "skip");
     } else if (to < from) {
       backEdges.push(edge);
     } else {
@@ -166,13 +168,20 @@ function classifyLayeredEdges(nodes, edges, rootId = nodes[0]?.id) {
         }
       }
     }
-    kindById.set(edge.id, closes ? "cycle" : "lateral");
+    kindById.set(edge.id, closes ? "cycle" : "back");
   }
   return { depthById, kindById };
 }
 function clusterIdFor(parentId, type, edgeType) {
   return `cluster:${parentId}:${type ?? ""}:${edgeType ?? ""}`;
 }
+function busPath(startX, startY, trunk, endX, endY) {
+  const dy = endY - startY;
+  if (Math.abs(dy) < 1) return `M${round1(startX)} ${round1(startY)} H${round1(endX)}`;
+  const r = Math.min(8, Math.abs(dy) / 2, trunk - startX, endX - trunk);
+  const dir = Math.sign(dy);
+  return `M${round1(startX)} ${round1(startY)} H${round1(trunk - r)} Q${round1(trunk)} ${round1(startY)} ${round1(trunk)} ${round1(startY + dir * r)} V${round1(endY - dir * r)} Q${round1(trunk)} ${round1(endY)} ${round1(trunk + r)} ${round1(endY)} H${round1(endX)}`;
+}
 const mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
 const round1 = (value) => Math.round(value * 10) / 10;
 function layoutLayeredGraph(nodes, edges, options = {}) {
@@ -200,6 +209,7 @@ function layoutLayeredGraph(nodes, edges, options = {}) {
   const forwardParents = /* @__PURE__ */ new Map();
   const forwardChildCount = /* @__PURE__ */ new Map();
   const inCycle = /* @__PURE__ */ new Set();
+  const crossLinked = /* @__PURE__ */ new Set();
   const nodeDegree = /* @__PURE__ */ new Map();
   for (const edge of drawable) {
     nodeDegree.set(edge.source, (nodeDegree.get(edge.source) ?? 0) + 1);
@@ -210,14 +220,18 @@ function layoutLayeredGraph(nodes, edges, options = {}) {
       else forwardParents.set(edge.target, [edge]);
       forwardChildCount.set(edge.source, (forwardChildCount.get(edge.source) ?? 0) + 1);
     } else {
-      inCycle.add(edge.source);
-      inCycle.add(edge.target);
+      crossLinked.add(edge.source);
+      crossLinked.add(edge.target);
+      if (kindById.get(edge.id) === "cycle") {
+        inCycle.add(edge.source);
+        inCycle.add(edge.target);
+      }
     }
   }
   const groups = /* @__PURE__ */ new Map();
   if (threshold > 0) {
     for (const node of nodes) {
-      if (node.id === rootId || inCycle.has(node.id) || (forwardChildCount.get(node.id) ?? 0) > 0) continue;
+      if (node.id === rootId || crossLinked.has(node.id) || (forwardChildCount.get(node.id) ?? 0) > 0) continue;
       const parents = forwardParents.get(node.id) ?? [];
       if (parents.length !== 1) continue;
       const via = parents[0];
@@ -369,7 +383,33 @@ function layoutLayeredGraph(nodes, edges, options = {}) {
     let labelY;
     let startAngle;
     let endAngle;
-    if (kind === "forward") {
+    if (kind === "skip") {
+      startX = from.x + from.width;
+      startY = from.y + from.height / 2;
+      endX = to.x;
+      endY = to.y + to.height / 2;
+      let floor = Math.max(startY, endY);
+      for (const item of itemById.values()) if (item.depth > from.depth && item.depth < to.depth) floor = Math.max(floor, item.y + item.height);
+      const channel = floor + 18;
+      const half = columnGap / 2;
+      path = `M${round1(startX)} ${round1(startY)} C${round1(startX + half)} ${round1(startY)} ${round1(startX + half)} ${round1(channel)} ${round1(startX + half)} ${round1(channel)} L${round1(endX - half)} ${round1(channel)} C${round1(endX - half)} ${round1(channel)} ${round1(endX - half)} ${round1(endY)} ${round1(endX)} ${round1(endY)}`;
+      labelX = (startX + endX) / 2;
+      labelY = channel;
+      startAngle = Math.PI;
+      endAngle = 0;
+      height = Math.max(height, channel + 8);
+    } else if (kind === "forward" && from.children.length > AUTO_LABEL_MAX_FANOUT) {
+      startX = from.x + from.width;
+      startY = from.y + from.height / 2;
+      endX = to.x;
+      endY = to.y + to.height / 2;
+      const trunk = startX + columnGap / 2;
+      path = busPath(startX, startY, trunk, endX, endY);
+      labelX = (trunk + endX) / 2;
+      labelY = endY;
+      startAngle = Math.PI;
+      endAngle = 0;
+    } else if (kind === "forward") {
       startX = from.x + from.width;
       startY = from.y + from.height / 2;
       endX = to.x;
@@ -415,6 +455,7 @@ function layoutLayeredGraph(nodes, edges, options = {}) {
       edgeIds: [edge.id],
       arrow,
       emphasis: edge.emphasis === true,
+      variant: edge.variant === "dashed" ? "dashed" : "solid",
       path,
       labelX: round1(labelX),
       labelY: round1(labelY),
@@ -422,13 +463,48 @@ function layoutLayeredGraph(nodes, edges, options = {}) {
       arrowY: round1(atStart ? startY : endY),
       arrowAngle: atStart ? startAngle : endAngle,
       labelLines: [],
+      columnLabel: false,
+      bus: kind === "forward" && from.children.length > AUTO_LABEL_MAX_FANOUT,
       autoLabel: to.kind !== "cluster" && (edge.emphasis === true || kind === "forward" && from.children.length <= AUTO_LABEL_MAX_FANOUT)
     };
     if (edge.type !== void 0) entry.type = edge.type;
+    if (edge.tone !== void 0) entry.tone = edge.tone;
+    if (edge.description !== void 0) entry.description = edge.description;
     const label = edge.label ?? edge.type;
     if (label !== void 0) entry.label = label;
     routed.set(key, entry);
   }
+  const intoColumn = /* @__PURE__ */ new Map();
+  for (const entry of routed.values()) {
+    if (entry.kind !== "forward" || entry.label === void 0) continue;
+    const depth = itemById.get(entry.target).depth;
+    const list = intoColumn.get(depth);
+    if (list) list.push(entry);
+    else intoColumn.set(depth, [entry]);
+  }
+  for (const [depth, entries] of intoColumn) {
+    if (entries.length <= AUTO_LABEL_MAX_FANOUT) continue;
+    const counts = /* @__PURE__ */ new Map();
+    for (const entry of entries) counts.set(entry.label, (counts.get(entry.label) ?? 0) + 1);
+    let dominant;
+    let most = 1;
+    for (const [label, count] of counts) if (count > most) {
+      dominant = label;
+      most = count;
+    }
+    if (dominant === void 0) continue;
+    const column = columns.find((candidate) => candidate.depth === depth);
+    if (column) column.edgeLabel = dominant;
+    for (const entry of entries) {
+      if (entry.emphasis) continue;
+      if (entry.label === dominant) {
+        entry.columnLabel = true;
+        entry.autoLabel = false;
+      } else if (itemById.get(entry.target).kind !== "cluster") {
+        entry.autoLabel = true;
+      }
+    }
+  }
   const seenLabels = /* @__PURE__ */ new Set();
   for (const entry of routed.values()) {
     if (entry.label === void 0) continue;
@@ -452,6 +528,35 @@ function layoutLayeredGraph(nodes, edges, options = {}) {
     headerHeight: LAYERED_HEADER
   };
 }
+function edgeLabelSize(lines) {
+  const longest = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  return { width: longest * LABEL_CHAR_WIDTH + 8, height: Math.max(1, lines.length) * 13 + 2 };
+}
+function separateEdgeLabels(boxes, options = {}) {
+  const gap = options.gap ?? 2;
+  const maxShift = options.maxShift ?? 40;
+  const placed = [];
+  const result = /* @__PURE__ */ new Map();
+  const ordered = [...boxes].sort((a, b) => a.y - b.y || a.x - b.x || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  for (const box of ordered) {
+    const left = box.x - box.width / 2;
+    const right = box.x + box.width / 2;
+    let top = box.y - box.height / 2;
+    for (let guard = 0; guard <= placed.length; guard += 1) {
+      const hit = placed.find((other) => left < other.right && other.left < right && top < other.bottom + gap && other.top - gap < top + box.height);
+      if (!hit) break;
+      top = hit.bottom + gap;
+    }
+    const shift = top - (box.y - box.height / 2);
+    if (shift > maxShift) {
+      result.set(box.id, { x: box.x, y: box.y, hidden: true });
+      continue;
+    }
+    placed.push({ left, right, top, bottom: top + box.height });
+    result.set(box.id, { x: box.x, y: round1(top + box.height / 2), hidden: false });
+  }
+  return result;
+}
 function layeredNeighbor(layout, currentId, key) {
   const root = layout.rootId !== void 0 ? layout.itemOf[layout.rootId] : layout.items[0]?.id;
   const current = layout.items.find((item) => item.id === currentId);
@@ -478,10 +583,12 @@ export {
   boundRelationshipGraph,
   classifyLayeredEdges,
   clusterIdFor,
+  edgeLabelSize,
   layeredNeighbor,
   layoutLayeredGraph,
   layoutRelationshipGraph,
   relationshipNeighbors,
+  separateEdgeLabels,
   traverseRelationshipNode,
   wrapEdgeLabel
 };

package/dist/reorder.d.ts

@@ -0,0 +1,30 @@
+import { PointerEvent } from 'react';
+
+/** Move `id` to `index` within `ids`. Returns `ids` itself when nothing moves. */
+declare function placeId(ids: readonly string[], id: string, index: number): readonly string[];
+/** True when two orders hold the same ids in the same order. */
+declare const sameOrder: (a: readonly string[], b: readonly string[]) => boolean;
+/**
+ * Where a dragged row lands: how many of the OTHER rows have their middle above the pointer.
+ * The rows reorder live while dragging, so counting the dragged row itself would push it one
+ * slot past the pointer every time it moves down.
+ */
+declare function dropIndex(rows: readonly Element[], dragged: Element | null, clientY: number): number;
+interface RowDragHandlers {
+    over: (id: string, index: number) => void;
+    drop: (id: string) => void;
+    /** The drag was cancelled (Escape, or the browser took the pointer): put the starting order back. */
+    cancel?: (id: string) => void;
+}
+/**
+ * Pointer drag for a list whose rows reorder live. It listens on the window for the whole drag:
+ * React moves the dragged row's DOM node when the order changes, which releases pointer capture on
+ * its grip, so after the first move down the grip itself stops receiving move and up events.
+ * Nothing animates: the row is placed where the pointer is, frame by frame.
+ */
+declare function useRowDrag(rowSelector: string, handlers: RowDragHandlers): {
+    dragging: string | null;
+    start: (event: PointerEvent<HTMLElement>, id: string) => void;
+};
+
+export { type RowDragHandlers, dropIndex, placeId, sameOrder, useRowDrag };

package/dist/reorder.js

@@ -0,0 +1,74 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+function placeId(ids, id, index) {
+  const from = ids.indexOf(id);
+  const to = Math.max(0, Math.min(index, ids.length - 1));
+  if (from < 0 || from === to) return ids;
+  const next = ids.filter((other) => other !== id);
+  next.splice(to, 0, id);
+  return next;
+}
+const sameOrder = (a, b) => a.length === b.length && a.every((id, i) => id === b[i]);
+function dropIndex(rows, dragged, clientY) {
+  let index = 0;
+  for (const row of rows) {
+    if (row === dragged) continue;
+    const box = row.getBoundingClientRect();
+    if (clientY > box.top + box.height / 2) index++;
+  }
+  return index;
+}
+function useRowDrag(rowSelector, handlers) {
+  const [dragging, setDragging] = useState(null);
+  const drag = useRef(null);
+  const latest = useRef(handlers);
+  latest.current = handlers;
+  useEffect(() => {
+    if (!dragging) return;
+    const move = (event) => {
+      const current = drag.current;
+      if (!current) return;
+      latest.current.over(current.id, dropIndex(Array.from(current.list.querySelectorAll(`:scope > ${rowSelector}`)), current.row, event.clientY));
+    };
+    const finish = (kind) => {
+      const current = drag.current;
+      drag.current = null;
+      setDragging(null);
+      if (!current) return;
+      if (kind === "drop") latest.current.drop(current.id);
+      else latest.current.cancel?.(current.id);
+    };
+    const end = () => finish("drop");
+    const cancel = () => finish("cancel");
+    const escape = (event) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      event.stopPropagation();
+      finish("cancel");
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", end);
+    window.addEventListener("pointercancel", cancel);
+    window.addEventListener("keydown", escape, true);
+    return () => {
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", end);
+      window.removeEventListener("pointercancel", cancel);
+      window.removeEventListener("keydown", escape, true);
+    };
+  }, [dragging, rowSelector]);
+  const start = (event, id) => {
+    const row = event.currentTarget.closest("li");
+    if (!row?.parentElement) return;
+    event.currentTarget.setPointerCapture?.(event.pointerId);
+    drag.current = { id, list: row.parentElement, row };
+    setDragging(id);
+  };
+  return { dragging, start };
+}
+export {
+  dropIndex,
+  placeId,
+  sameOrder,
+  useRowDrag
+};

package/dist/rich-text.cjs

@@ -1700,6 +1700,8 @@ function Popover({
     };
     const onKeyDown = (event) => {
       if (event.key !== "Escape" || !isPopoverOpen(el)) return;
+      event.preventDefault();
+      event.stopPropagation();
       window.clearTimeout(timer);
       const hadFocus = el.contains(el.ownerDocument.activeElement);
       try {
@@ -2170,11 +2172,11 @@ function Markdown({
 var import_react6 = require("react");
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var Textarea = (0, import_react6.forwardRef)(
-  ({ invalid, className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+  ({ invalid, size = "md", className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
     "textarea",
     {
       ref,
-      className: cx("uix-textarea", className),
+      className: cx("uix-textarea", size === "lg" && "uix-textarea--lg", className),
       "aria-invalid": invalid || void 0,
       ...props
     }

package/dist/scheduling-resource-model.d.ts

@@ -0,0 +1,76 @@
+/** What a span of a resource's day is: open to book, booked, or not working. */
+type SchedulingAvailabilityKind = 'free' | 'booked' | 'off';
+/** One column of the resource day, e.g. a practitioner. */
+interface SchedulingResource {
+    id: string;
+    /** The column heading and the start of every slot's accessible name. */
+    label: string;
+    /** A second line under the heading, e.g. the speciality or the room. */
+    description?: string;
+}
+/** A stretch of one resource's day, as the server composed it. */
+interface SchedulingResourceSpan {
+    id: string;
+    resourceId: string;
+    /** ISO 8601 instants, half-open `[start, end)`. */
+    start: string;
+    end: string;
+    kind: SchedulingAvailabilityKind;
+    /** Shown on the span, e.g. the patient's name on a booking or "Lunch" on time off. */
+    label?: string;
+    /** The complete accessible name, in the consumer's words. Replaces the built one. */
+    accessibleName?: string;
+}
+/** One row of the slot axis. */
+interface ResourceDaySlot {
+    /** Epoch milliseconds of the slot's start and end. */
+    start: number;
+    end: number;
+    /** The local time it starts, `HH:MM`, in the display zone. */
+    label: string;
+}
+interface ResourceDaySlotOptions {
+    /** The first local time shown, `HH:MM`. Default `'07:00'`. */
+    dayStart?: string;
+    /** The local time the axis ends, `HH:MM` (exclusive). Default `'19:00'`. */
+    dayEnd?: string;
+    /** Minutes per slot. Default 15. */
+    slotMinutes?: number;
+}
+/** One drawn piece of a column: a bookable slot of a free span, a booking, or time off. */
+interface ResourceDayItem {
+    key: string;
+    span: SchedulingResourceSpan;
+    kind: SchedulingAvailabilityKind;
+    /** Epoch milliseconds of what this piece covers (a free span is cut at slot edges). */
+    start: number;
+    end: number;
+    /** Slots from the top of the axis to the piece's start (fractional). */
+    offset: number;
+    /** Slots the piece is long (fractional). */
+    length: number;
+    lane: number;
+    lanes: number;
+    /** The span starts before or ends after the axis. */
+    continuesBefore: boolean;
+    continuesAfter: boolean;
+}
+/**
+ * The slot axis of `date` in `timeZone`: one slot per `slotMinutes` of real time from the first
+ * local time at or after `dayStart` to the last before `dayEnd`. On a clock-change day the axis
+ * is as long as the day really is (a skipped hour has no slots; a repeated hour has two sets).
+ */
+declare function resourceDaySlots(date: string, timeZone: string, options?: ResourceDaySlotOptions): ResourceDaySlot[];
+/**
+ * Where the spans of one resource go on the slot axis. Free spans are cut at slot edges, so each
+ * bookable slot is its own piece; bookings and time off stay whole. Pieces outside the axis are
+ * dropped, pieces across its edges are clipped. Overlapping pieces (a double booking) get lanes.
+ */
+declare function layoutResourceColumn(spans: readonly SchedulingResourceSpan[], slots: readonly ResourceDaySlot[]): ResourceDayItem[];
+/** The stretches of the axis no span covers: shown as "no schedule", never as free. */
+declare function resourceDayGaps(items: readonly ResourceDayItem[], slots: readonly ResourceDaySlot[]): Array<{
+    start: number;
+    end: number;
+}>;
+
+export { type ResourceDayItem, type ResourceDaySlot, type ResourceDaySlotOptions, type SchedulingAvailabilityKind, type SchedulingResource, type SchedulingResourceSpan, layoutResourceColumn, resourceDayGaps, resourceDaySlots };

package/dist/scheduling-resource-model.js

@@ -0,0 +1,74 @@
+import { packLanes, zonedDayBounds, zonedTimeOfDay } from "./calendar-model.js";
+const MINUTE = 6e4;
+const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+function resourceDaySlots(date, timeZone, options = {}) {
+  const dayStart = options.dayStart && TIME.test(options.dayStart) ? options.dayStart : "07:00";
+  const dayEnd = options.dayEnd && TIME.test(options.dayEnd) ? options.dayEnd : "19:00";
+  const minutes = Number.isFinite(options.slotMinutes) && options.slotMinutes >= 5 ? Math.floor(options.slotMinutes) : 15;
+  const step = minutes * MINUTE;
+  const bounds = zonedDayBounds(date, timeZone);
+  const all = [];
+  for (let at = bounds.start.getTime(); at < bounds.end.getTime(); at += step) {
+    all.push({ start: at, end: Math.min(at + step, bounds.end.getTime()), label: zonedTimeOfDay(at, timeZone) });
+  }
+  const first = all.findIndex((slot) => slot.label >= dayStart);
+  let last = -1;
+  all.forEach((slot, index) => {
+    if (slot.label < dayEnd) last = index;
+  });
+  if (first === -1 || last < first) return [];
+  return all.slice(first, last + 1);
+}
+function layoutResourceColumn(spans, slots) {
+  if (slots.length === 0) return [];
+  const axisStart = slots[0].start;
+  const axisEnd = slots[slots.length - 1].end;
+  const slotMs = slots[0].end - slots[0].start;
+  const pieces = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const span of spans) {
+    if (seen.has(span.id)) continue;
+    seen.add(span.id);
+    const start = new Date(span.start).getTime();
+    const end = new Date(span.end).getTime();
+    if (!(end > start) || end <= axisStart || start >= axisEnd) continue;
+    const from = Math.max(start, axisStart);
+    const to = Math.min(end, axisEnd);
+    const edges = { continuesBefore: start < axisStart, continuesAfter: end > axisEnd };
+    if (span.kind === "free") {
+      for (const slot of slots) {
+        const a = Math.max(from, slot.start);
+        const b = Math.min(to, slot.end);
+        if (b > a) pieces.push({ key: `${span.id}@${a}`, span, kind: "free", start: a, end: b, ...edges });
+      }
+    } else pieces.push({ key: span.id, span, kind: span.kind, start: from, end: to, ...edges });
+  }
+  const packed = packLanes(pieces.map((piece) => ({ id: piece.key, start: piece.start, end: piece.end })), Infinity);
+  return pieces.map((piece) => {
+    const placement = packed.lanes[piece.key];
+    return {
+      ...piece,
+      offset: (piece.start - axisStart) / slotMs,
+      length: (piece.end - piece.start) / slotMs,
+      lane: placement.lane ?? 0,
+      lanes: packed.clusters[placement.cluster].laneCount || 1
+    };
+  }).sort((a, b) => a.start - b.start || a.lane - b.lane);
+}
+function resourceDayGaps(items, slots) {
+  if (slots.length === 0) return [];
+  const gaps = [];
+  let at = slots[0].start;
+  for (const item of [...items].sort((a, b) => a.start - b.start)) {
+    if (item.start > at) gaps.push({ start: at, end: item.start });
+    at = Math.max(at, item.end);
+  }
+  const axisEnd = slots[slots.length - 1].end;
+  if (at < axisEnd) gaps.push({ start: at, end: axisEnd });
+  return gaps;
+}
+export {
+  layoutResourceColumn,
+  resourceDayGaps,
+  resourceDaySlots
+};

package/dist/search-suggest-model.js

@@ -1,11 +1,13 @@
 const COMBINING_MARK = /\p{M}/u;
+const STROKED = { "\u0111": "d", "\xF8": "o", "\u0142": "l", "\u0131": "i", "\u0127": "h", "\u0167": "t" };
 function foldForSearch(text) {
   let folded = "";
   const source = [];
   const sourceEnd = [];
   let index = 0;
   for (const char of text) {
-    const base = char === "\xDF" || char === "\u1E9E" ? "ss" : char.toLowerCase().normalize("NFD");
+    const lower = char.toLowerCase();
+    const base = char === "\xDF" || char === "\u1E9E" ? "ss" : STROKED[lower] ?? lower.normalize("NFD");
     for (const part of base) {
       if (COMBINING_MARK.test(part)) continue;
       folded += part;

package/dist/shell-context.d.ts

@@ -0,0 +1,11 @@
+import * as react from 'react';
+
+/**
+ * True inside AppShell's phone navigation drawer (HAR-1371). The sidebar there is shown full,
+ * whatever tier a person chose on a wide screen: a Sidebar and an AccountMenu read this and drop
+ * their rail form. Internal: not exported from the package.
+ */
+declare const ShellDrawerContext: react.Context<boolean>;
+declare const useInShellDrawer: () => boolean;
+
+export { ShellDrawerContext, useInShellDrawer };

package/dist/shell-context.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from "react";
+const ShellDrawerContext = createContext(false);
+const useInShellDrawer = () => useContext(ShellDrawerContext);
+export {
+  ShellDrawerContext,
+  useInShellDrawer
+};