@tensor_1/react 2.47.0 → 2.49.0

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
+};

package/dist/time-field-model.d.ts

@@ -0,0 +1,46 @@
+/**
+ * uix time-field model — pure helpers behind `TimePicker` (HAR-1835): how a locale writes a time
+ * of day, how a typed time is read, and how the arrow keys step it. No DOM, no React, no runtime
+ * import, so the unit test loads this file directly (time-field-model.test.mjs).
+ *
+ * A time is a wall-clock `HH:mm` string (what `<input type="time">` holds): 24-hour, zero-padded,
+ * no seconds, no zone.
+ */
+/** Whether `HH:mm` names a time of day (00:00 to 23:59). */
+declare function isValidTimeKey(value: string | null | undefined): value is string;
+/** Minutes since midnight of `HH:mm`. */
+declare const timeToMinutes: (value: string) => number;
+/** `HH:mm` of a minute of the day (wrapped into 0 … 1439). */
+declare const minutesToTime: (minutes: number) => string;
+/** Whether `locale` writes times on a 12-hour clock (en-US: yes; de, en-GB, bs: no). */
+declare function uses12Hour(locale?: string | readonly string[]): boolean;
+/** A time in the locale's own shape: 14:30 in German, 2:30 PM in en-US. `hour12` overrides the locale. */
+declare function formatTimeKey(value: string, locale?: string | readonly string[], hour12?: boolean): string;
+/**
+ * Where the hour and the minutes end in `formatTimeKey(value, locale, hour12)` (character offsets),
+ * found from the formatter's own parts, so "오후 2:30" (ko, the day period first) and "2:30 PM"
+ * both work. `null` when the value is not a time.
+ */
+declare function timePartEnds(value: string, locale?: string | readonly string[], hour12?: boolean): {
+    hour: number;
+    minute: number;
+} | null;
+/**
+ * Read a typed time. Accepts `14:30`, `14.30`, `14h30`, `1430`, `930`, `9` and, with a day period,
+ * `2:30 pm`, `2pm`, `2:30 p.m.` (and the locale's own words). Without a day period the hour is
+ * read on the 24-hour clock. Returns `HH:mm`, or `null` when the text is not a time.
+ */
+declare function parseTimeInput(text: string, locale?: string | readonly string[]): string | null;
+/** Whether `min` is after `max`: an overnight range (22:00 to 06:00) that wraps round midnight. */
+declare const isOvernightRange: (min?: string, max?: string) => boolean;
+/** Whether `value` is outside `min` / `max` (both `HH:mm`, inclusive; `min` after `max` wraps midnight). */
+declare function isTimeOutOfRange(value: string, min?: string, max?: string): boolean;
+/**
+ * The time `delta` minutes from `value`, for the arrow keys. Between `min` and `max` it stops at
+ * the ends; with neither it wraps round midnight. From an empty field it starts at `min`, or 00:00.
+ */
+declare function stepTime(value: string | null, delta: number, min?: string, max?: string): string;
+/** The times a list offers: every `step` minutes from `min` (or 00:00) to `max` (or 23:59). */
+declare function timeSlots(step: number, min?: string, max?: string): string[];
+
+export { formatTimeKey, isOvernightRange, isTimeOutOfRange, isValidTimeKey, minutesToTime, parseTimeInput, stepTime, timePartEnds, timeSlots, timeToMinutes, uses12Hour };

package/dist/time-field-model.js

@@ -0,0 +1,152 @@
+const pad = (n) => String(n).padStart(2, "0");
+function isValidTimeKey(value) {
+  const match = value ? /^(\d{2}):(\d{2})$/.exec(value) : null;
+  return !!match && Number(match[1]) < 24 && Number(match[2]) < 60;
+}
+const timeToMinutes = (value) => Number(value.slice(0, 2)) * 60 + Number(value.slice(3, 5));
+const minutesToTime = (minutes) => {
+  const m = (Math.round(minutes) % 1440 + 1440) % 1440;
+  return `${pad(Math.floor(m / 60))}:${pad(m % 60)}`;
+};
+function uses12Hour(locale) {
+  try {
+    const options = new Intl.DateTimeFormat(locale, { hour: "numeric" }).resolvedOptions();
+    const cycle = options.hourCycle;
+    return cycle === "h11" || cycle === "h12";
+  } catch {
+    return false;
+  }
+}
+const at = (value) => new Date(Date.UTC(2026, 0, 1, Number(value.slice(0, 2)), Number(value.slice(3, 5))));
+function formatTimeKey(value, locale, hour12) {
+  if (!isValidTimeKey(value)) return value;
+  const twelve = hour12 ?? uses12Hour(locale);
+  try {
+    return new Intl.DateTimeFormat(locale, {
+      hour: twelve ? "numeric" : "2-digit",
+      minute: "2-digit",
+      hourCycle: twelve ? "h12" : "h23",
+      timeZone: "UTC"
+    }).format(at(value));
+  } catch {
+    return value;
+  }
+}
+function timePartEnds(value, locale, hour12) {
+  if (!isValidTimeKey(value)) return null;
+  const twelve = hour12 ?? uses12Hour(locale);
+  try {
+    const parts = new Intl.DateTimeFormat(locale, {
+      hour: twelve ? "numeric" : "2-digit",
+      minute: "2-digit",
+      hourCycle: twelve ? "h12" : "h23",
+      timeZone: "UTC"
+    }).formatToParts(at(value));
+    let offset = 0;
+    let hour = -1;
+    let minute = -1;
+    for (const part of parts) {
+      offset += part.value.length;
+      if (part.type === "hour") hour = offset;
+      if (part.type === "minute") minute = offset;
+    }
+    return hour >= 0 && minute >= 0 ? { hour, minute } : null;
+  } catch {
+    return null;
+  }
+}
+function dayPeriods(locale) {
+  const am = ["am", "a.m.", "a"];
+  const pm = ["pm", "p.m.", "p"];
+  try {
+    const fmt = new Intl.DateTimeFormat(locale, { hour: "numeric", hourCycle: "h12", timeZone: "UTC" });
+    const word = (hour) => fmt.formatToParts(at(`${pad(hour)}:00`)).find((p2) => p2.type === "dayPeriod")?.value.trim().toLowerCase();
+    const a = word(1);
+    const p = word(13);
+    if (a && !am.includes(a)) am.unshift(a);
+    if (p && !pm.includes(p)) pm.unshift(p);
+  } catch {
+  }
+  return { am, pm };
+}
+function parseTimeInput(text, locale) {
+  let rest = text.normalize("NFKC").trim().toLowerCase().replace(/\s+/g, " ");
+  if (!rest) return null;
+  let period = null;
+  const { am, pm } = dayPeriods(locale);
+  const words = [...am.map((w) => [w, "am"]), ...pm.map((w) => [w, "pm"])].sort((x, y) => y[0].length - x[0].length);
+  for (const [word, which] of words) {
+    if (rest.endsWith(word) && /[\d\s.]$/.test(rest.slice(0, -word.length) || " ")) {
+      period = which;
+      rest = rest.slice(0, -word.length).trim();
+      break;
+    }
+    if (rest.startsWith(word) && /^[\s\d]/.test(rest.slice(word.length))) {
+      period = which;
+      rest = rest.slice(word.length).trim();
+      break;
+    }
+  }
+  let hour;
+  let minute;
+  const split = /^(\d{1,2})\s*(?:[:.h]\s*(\d{1,2}))?\s*(?:h|uhr)?$/.exec(rest);
+  const packed = /^(\d{3,4})$/.exec(rest);
+  if (split && (split[2] === void 0 || split[2].length === 2)) {
+    hour = Number(split[1]);
+    minute = split[2] === void 0 ? 0 : Number(split[2]);
+  } else if (packed) {
+    hour = Number(packed[1].slice(0, -2));
+    minute = Number(packed[1].slice(-2));
+  } else {
+    return null;
+  }
+  if (minute > 59) return null;
+  if (period) {
+    if (hour < 1 || hour > 12) return null;
+    hour = hour % 12 + (period === "pm" ? 12 : 0);
+  } else if (hour > 23) {
+    return null;
+  }
+  return `${pad(hour)}:${pad(minute)}`;
+}
+const isOvernightRange = (min, max) => !!min && !!max && isValidTimeKey(min) && isValidTimeKey(max) && min > max;
+function isTimeOutOfRange(value, min, max) {
+  if (isOvernightRange(min, max)) return value < min && value > max;
+  return !!min && isValidTimeKey(min) && value < min || !!max && isValidTimeKey(max) && value > max;
+}
+function stepTime(value, delta, min, max) {
+  const lo = min && isValidTimeKey(min) ? timeToMinutes(min) : null;
+  const hi = max && isValidTimeKey(max) ? timeToMinutes(max) : null;
+  if (!value || !isValidTimeKey(value)) return minutesToTime(lo ?? 0);
+  if (lo !== null && hi !== null && lo > hi) {
+    const wrapped = ((timeToMinutes(value) + delta) % 1440 + 1440) % 1440;
+    return minutesToTime(wrapped >= lo || wrapped <= hi ? wrapped : delta > 0 ? hi : lo);
+  }
+  let next = timeToMinutes(value) + delta;
+  if (lo === null && hi === null) return minutesToTime(next);
+  if (lo !== null && next < lo) next = lo;
+  if (hi !== null && next > hi) next = hi;
+  return minutesToTime(Math.max(0, Math.min(1439, next)));
+}
+function timeSlots(step, min, max) {
+  const size = Math.max(1, Math.round(step));
+  const lo = min && isValidTimeKey(min) ? timeToMinutes(min) : 0;
+  const hi = max && isValidTimeKey(max) ? timeToMinutes(max) : 1439;
+  const out = [];
+  const end = lo > hi ? hi + 1440 : hi;
+  for (let m = lo; m <= end; m += size) out.push(minutesToTime(m));
+  return out;
+}
+export {
+  formatTimeKey,
+  isOvernightRange,
+  isTimeOutOfRange,
+  isValidTimeKey,
+  minutesToTime,
+  parseTimeInput,
+  stepTime,
+  timePartEnds,
+  timeSlots,
+  timeToMinutes,
+  uses12Hour
+};

package/dist/toast-store.d.ts

@@ -25,6 +25,13 @@ interface ToastOptions {
      * Defaults: success/info/default 5 s, warning 8 s, error and loading stay.
      */
     duration?: number | null;
+    /**
+     * `false`: a fixed timer (HAR-1831). The toast closes `duration` after it appears, even while the
+     * pointer or focus is on it or the tab is hidden; for an undo window that must end on time
+     * (TENSOR's `useUndoableAction` commits after exactly 5 s). A toast waiting beyond the
+     * Toaster's `limit` starts its timer when it appears. Default `true`: the timer pauses.
+     */
+    pauseOnHover?: boolean;
     action?: ToastAction;
     /** Replaces the tone glyph. */
     icon?: ReactNode;
@@ -37,6 +44,8 @@ interface ToastRecord {
     message: ReactNode;
     description?: ReactNode;
     duration: number | null;
+    /** `false`: the timer does not pause (see {@link ToastOptions.pauseOnHover}). */
+    pauseOnHover?: boolean;
     action?: ToastAction;
     icon?: ReactNode;
     /** Set while the leave animation runs; the record is removed after it. */
@@ -65,8 +74,11 @@ interface ToastStore {
     subscribe: (listener: () => void) => () => void;
     getSnapshot: () => readonly ToastRecord[];
 }
-/** How long the leave animation gets before the record is removed. */
-declare const TOAST_LEAVE_MS = 200;
+/**
+ * How long the leave transition gets before the record is removed when no stylesheet answers:
+ * the store reads `--uix-dur-exit` (toast.css leaves on it), so the two never disagree (HAR-2578).
+ */
+declare const TOAST_LEAVE_MS = 110;
 /** A separate queue, e.g. per test or per embedded app. Most products use the default `toast`. */
 declare function createToastStore(): ToastStore;
 interface ToastApi {
@@ -84,9 +96,16 @@ interface ToastApi {
     promise: <T>(promise: Promise<T>, messages: ToastPromiseMessages<T>, options?: ToastOptions) => Promise<T>;
     /**
      * An optimistic action with an Undo button (TENSOR C2 `useUndoableAction`): `onCommit` runs
-     * when the toast closes without Undo; `onUndo` runs instead when Undo is pressed.
+     * when the toast closes without Undo; `onUndo` runs instead when Undo is pressed. Pass
+     * `pauseOnHover: false` for a commit that happens exactly `duration` after the toast appears.
      */
     undoable: (message: ReactNode, options: UndoableToastOptions) => string;
+    /**
+     * Undo an `undoable` toast from code, as if its Undo were pressed (HAR-1831): `onUndo` runs,
+     * `onCommit` does not, and the toast closes. Returns `false` when `id` is not an open undoable
+     * toast (it was already undone or committed). `dismiss(id)` commits instead.
+     */
+    undo: (id: string) => boolean;
     /** The store this API writes to; pass it to `<Toaster store>` for a non-default queue. */
     store: ToastStore;
 }

package/dist/toast-store.js

@@ -1,3 +1,4 @@
+import { tokenMs } from "./motion.js";
 const DEFAULT_DURATION = {
   success: 5e3,
   info: 5e3,
@@ -6,7 +7,7 @@ const DEFAULT_DURATION = {
   error: null,
   loading: null
 };
-const TOAST_LEAVE_MS = 200;
+const TOAST_LEAVE_MS = 110;
 let counter = 0;
 function createToastStore() {
   let records = [];
@@ -26,6 +27,7 @@ function createToastStore() {
       message,
       description: options.description,
       duration: options.duration === void 0 ? DEFAULT_DURATION[kind] : options.duration,
+      pauseOnHover: options.pauseOnHover,
       action: options.action,
       icon: options.icon,
       onDismiss: options.onDismiss,
@@ -51,7 +53,7 @@ function createToastStore() {
     set(records.map((r) => ids.has(r.id) ? { ...r, leaving: true } : r));
     for (const r of closing) r.onDismiss?.(reason);
     const remove = () => set(records.filter((r) => !(ids.has(r.id) && r.leaving)));
-    if (typeof setTimeout === "function") setTimeout(remove, TOAST_LEAVE_MS);
+    if (typeof setTimeout === "function") setTimeout(remove, tokenMs("--uix-dur-exit", TOAST_LEAVE_MS));
     else remove();
   };
   return {
@@ -84,19 +86,34 @@ function createToastApi(store) {
     );
     return promise;
   };
+  const undoers = /* @__PURE__ */ new Map();
   api.undoable = (message, { onUndo, onCommit, undoLabel = "Undo", duration = 6e3, ...options }) => {
-    let undone = false;
-    return store.show("default", message, {
+    let settled = false;
+    const undo = () => {
+      if (settled) return;
+      settled = true;
+      onUndo();
+    };
+    const id = store.show("default", message, {
       ...options,
       duration,
-      action: { label: undoLabel, onClick: () => {
-        undone = true;
-        onUndo();
-      } },
+      action: { label: undoLabel, onClick: undo },
       onDismiss: () => {
-        if (!undone) onCommit();
+        undoers.delete(id);
+        if (settled) return;
+        settled = true;
+        onCommit();
       }
     });
+    undoers.set(id, undo);
+    return id;
+  };
+  api.undo = (id) => {
+    const undo = undoers.get(id);
+    if (!undo) return false;
+    undo();
+    store.dismiss(id, "action");
+    return true;
   };
   api.store = store;
   return api;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor_1/react",
-  "version": "2.47.0",
+  "version": "2.49.0",
   "description": "Thin React wrappers over the UIx v2 CSS component library.",
   "license": "UNLICENSED",
   "type": "module",
@@ -149,6 +149,7 @@
     "emojibase-data": "17.0.0",
     "esbuild": "^0.27.0",
     "jsdom": "30.1.0",
+    "jsqr": "1.4.0",
     "marked": "17.0.6",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"