@tensor_1/react 2.46.0 → 2.48.0

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. */
@@ -84,9 +93,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

@@ -26,6 +26,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,
@@ -84,19 +85,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.46.0",
+  "version": "2.48.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"