@tensor_1/react 2.35.0 → 2.37.0

package/dist/components/SchedulingAgenda.js

@@ -4,6 +4,7 @@ import { createElement, useEffect, useLayoutEffect, useRef, useState } from "rea
 import { addCalendarDays, zonedDateKey, zonedTimeOfDay } from "../calendar-model.js";
 import { itemDaySpan } from "../scheduling-calendar-model.js";
 import { useVirtualRows } from "../hooks/useVirtualRows.js";
+import { usePrinting } from "../hooks/usePrinting.js";
 import { fillLabel } from "../fill-label.js";
 import { syncRovingStop } from "../roving.js";
 const AGENDA_VIRTUAL_ROW = 44;
@@ -58,7 +59,8 @@ function AgendaBody({
     });
   }
   const [narrow, setNarrow] = useState(false);
-  const virtual = useVirtualRows(flatRows, { rowHeight: narrow ? AGENDA_NARROW_ROW : AGENDA_VIRTUAL_ROW, threshold: 0, estimatedViewportHeight: AGENDA_VIRTUAL_VIEWPORT });
+  const printing = usePrinting(flat);
+  const virtual = useVirtualRows(flatRows, { rowHeight: narrow ? AGENDA_NARROW_ROW : AGENDA_VIRTUAL_ROW, threshold: 0, estimatedViewportHeight: AGENDA_VIRTUAL_VIEWPORT, enabled: !printing });
   const scroller = virtual.containerRef;
   useLayoutEffect(() => {
     const box = scroller.current;

package/dist/components/SchedulingTimeGrid.js

@@ -25,16 +25,18 @@ const GridItem = memo(function GridItem2({ entry, segment, column, alone, name,
     "--uix-scheduling-calendar-lane": segment.lane,
     "--uix-scheduling-calendar-lanes": segment.laneCount
   });
-  const text = renderEntry?.(entry, { availableLines: lines }) ?? (lines > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+  const custom = renderEntry?.(entry, { availableLines: lines });
+  const text = custom ?? /* @__PURE__ */ jsxs(Fragment, { children: [
     !continuation && /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__time", children: zonedTimeOfDay(entry.start, timeZone) }),
       " "
     ] }),
     /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__title", children: entry.title })
-  ] }) : null);
+  ] });
+  const noRoom = lines === 0 && (custom === void 0 || custom === null) ? "none" : void 0;
   const body = /* @__PURE__ */ jsxs(Fragment, { children: [
-    continuation && lines > 0 && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__tg-from", children: continuesFrom }),
-    (!continuation || alone) && text != null && text !== false && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__entry-text", children: text }),
+    continuation && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__tg-from", "data-room": lines === 0 ? "none" : void 0, children: continuesFrom }),
+    (!continuation || alone) && text != null && text !== false && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__entry-text", "data-room": noRoom, children: text }),
     markers.length > 0 && /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__markers", children: markers.map((marker) => /* @__PURE__ */ jsx("span", { children: renderMarker(marker) }, marker.id)) })
   ] });
   const shared = {

package/dist/components/SchedulingTimeline.d.ts

@@ -1,9 +1,9 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
+import { MoveProposal } from '../scheduling-calendar-model.js';
 import { TimelineRange, TimelineScale } from '../scheduling-timeline-model.js';
-import { j as SchedulingEntryState } from '../SchedulingCalendar-B6TakO2h.js';
+import { j as SchedulingEntryState, p as SchedulingStatus, a as SchedulingBand, l as SchedulingMarker, o as SchedulingOverlayPattern } from '../SchedulingCalendar-B6TakO2h.js';
 import '../calendar-model.js';
-import '../scheduling-calendar-model.js';
 
 interface SchedulingTimelineLane {
     id: string;
@@ -11,6 +11,25 @@ interface SchedulingTimelineLane {
     /** A quieter second line under the lane name (an owner, a count). */
     meta?: ReactNode;
 }
+/** A collapsible block of lanes. The consumer builds the groups and owns every number on them. */
+interface SchedulingTimelineGroup {
+    id: string;
+    label: ReactNode;
+    /** A quieter text beside the group name. */
+    meta?: ReactNode;
+    /** The lanes of the group, in the order to draw them. A lane named by two groups is drawn in the first. */
+    laneIds: string[];
+    /**
+     * A collapsed group is one row. With `onToggleGroup` the consumer owns this value; without
+     * it, it is where the group starts and the timeline opens and closes the group itself.
+     */
+    collapsed?: boolean;
+    /** Shown on the one row of a collapsed group. The timeline derives neither the count nor a marker. */
+    summary?: {
+        count: number;
+        markers?: SchedulingMarker[];
+    };
+}
 interface SchedulingTimelineItem {
     id: string;
     laneId: string;
@@ -18,34 +37,61 @@ interface SchedulingTimelineItem {
     /** ISO 8601 instants. */
     start: string;
     end: string;
+    /** @deprecated Use `band`, `status` and `markers`. The values keep working in 2.x; a bar is no longer tinted by them. */
     state?: SchedulingEntryState;
     meta?: string;
-    /** `false` keeps this bar fixed even when `onMoveItem` is set. */
+    /** `false` keeps this bar fixed even when a move or resize callback is set. */
     movable?: boolean;
+    /** The one dimension that takes a hue: only `high` is filled. */
+    band?: SchedulingBand;
+    /** Drawn as a line style, never as a hue. */
+    status?: SchedulingStatus;
+    /** Shapes or icons with text. The text is in the accessible name. */
+    markers?: SchedulingMarker[];
+    /** The complete accessible name, built by the consumer from its own words. Replaces `labels.item`. */
+    accessibleName?: string;
 }
+/** @deprecated Use `pattern` and `kindLabel` on the overlay. The values keep working in 2.x. */
 type SchedulingTimelineOverlayKind = 'freeze' | 'maintenance' | 'blackout';
 interface SchedulingTimelineOverlay {
     id: string;
+    /** The name of the window, shown as text. */
     label: string;
     start: string;
     end: string;
-    kind: SchedulingTimelineOverlayKind;
-    /** Only this lane; every lane when unset. */
+    /** @deprecated Use `pattern` and `kindLabel`. */
+    kind?: SchedulingTimelineOverlayKind;
+    /** Only this lane. For several lanes use `laneIds`. */
     laneId?: string;
+    /** Only these lanes; every lane when neither this nor `laneId` is set. The window is still one element. */
+    laneIds?: string[];
+    /** How the window is hatched. Windows are neutral: the pattern and the visible words tell them apart. */
+    pattern?: SchedulingOverlayPattern;
+    /** What kind of window this is, in the words of the consumer. Shown before the name. */
+    kindLabel?: string;
+    /** What the window applies to. Shown after the name. */
+    scopeLabel?: string;
+    /** The complete accessible name. Replaces `labels.overlay`. */
+    accessibleName?: string;
 }
 interface SchedulingTimelineMarker {
     id: string;
     label: string;
     /** ISO 8601 instant. */
     at: string;
+    /** Only this lane. For several lanes use `laneIds`. */
     laneId?: string;
+    /** Only these lanes; every lane when neither this nor `laneId` is set. */
+    laneIds?: string[];
 }
 interface SchedulingTimelineLabels {
     region: string;
     lanes: string;
-    /** `{title}`, `{state}`, `{start}`, `{end}`, `{conflict}`. */
+    /** The accessible name of a bar unless it sets `accessibleName`. `{title}`, `{state}`, `{start}`, `{end}`, `{conflict}`. Its marker labels are appended. */
     item: string;
+    /** Read after a bar that shares time with another bar of its lane, while `flagOverlaps` is on. */
     conflict: string;
+    /** The hint of a timeline that has both `onMoveItem` and `onResizeItem` (the older sentence). */
     moveHint: string;
     /** Announced after a move. `{title}`, `{start}`, `{end}`. */
     moved: string;
@@ -57,8 +103,30 @@ interface SchedulingTimelineLabels {
     /** Heading of the screen-reader list of windows and markers. */
     windows: string;
     now: string;
+    /** @deprecated The words of `item.state`. Use `status` on the item, named by `statuses`. */
     states: Record<SchedulingEntryState, string>;
+    /** @deprecated The words of `overlay.kind`. Use `kindLabel` on the overlay. */
     overlays: Record<SchedulingTimelineOverlayKind, string>;
+    /** The words for `status`, used in the default accessible name. */
+    statuses?: Partial<Record<SchedulingStatus, string>>;
+    /** The accessible name of a window that can be selected. `{title}` is its kind, name and scope. */
+    overlay?: string;
+    /** The hint of a bar that `onMoveItem` moves, one step a key press. */
+    moveKeysHint?: string;
+    /** The hint of a bar whose end `onResizeItem` moves. */
+    resizeHint?: string;
+    /** The hint of a bar that `onProposeMove` moves. */
+    proposeHint?: string;
+    /** Announced for a pending move. `{start}` and `{end}` placeholders. */
+    moveProposed?: string;
+    /** Announced when a pending move is dropped. */
+    moveCancelled?: string;
+    /** Announced when the time asked for does not exist that day. `{time}` is the time used instead. */
+    gapForward?: string;
+    /** The count on the row of a collapsed group. `{count}` is the number the consumer gave; the wording, plural forms included, is this label. */
+    groupSummary?: string;
+    /** Announced when a move was handed to `onProposeMove`. `{start}` and `{end}` placeholders. */
+    moveSent?: string;
 }
 declare const DEFAULT_SCHEDULING_TIMELINE_LABELS: SchedulingTimelineLabels;
 interface SchedulingTimelineProps {
@@ -71,7 +139,16 @@ interface SchedulingTimelineProps {
     /** IANA zone for tick boundaries and every printed time. */
     timeZone: string;
     locale?: string;
+    /**
+     * Collapsible blocks of lanes, in the order given. Lanes that no group names are drawn after
+     * the groups. Unset keeps the flat list of lanes.
+     */
+    groups?: SchedulingTimelineGroup[];
+    /** Called by a group head. When set, the consumer flips `collapsed`; nothing opens until the props say so. */
+    onToggleGroup?: (id: string) => void;
     overlays?: SchedulingTimelineOverlay[];
+    /** Makes each window a button. Called by a click or Enter on it. */
+    onSelectOverlay?: (overlay: SchedulingTimelineOverlay) => void;
     markers?: SchedulingTimelineMarker[];
     /** Draws a "now" line at this instant (pass the current time; the component keeps no clock). */
     now?: string;
@@ -81,18 +158,53 @@ interface SchedulingTimelineProps {
     tickWidth?: string;
     /** Move/resize granularity in ms. Defaults: 15 min (hour), 1 h (day), 1 day (week, month). */
     step?: number;
-    /** Tick label. Default: `Intl` in `locale` and `timeZone`. */
+    /** Local hours (0–23) that get a minor tick inside each day of a `day` axis, e.g. `[6, 12, 18]`. */
+    subTicks?: number[];
+    /** Tick label. Default: `Intl` in `locale` and `timeZone`. A sub-tick asks with the scale `'hour'`. */
     formatTick?: (at: Date, scale: TimelineScale) => string;
     /** Start/end text in names and announcements. Default: `Intl` medium date + short time in `timeZone`. */
     formatInstant?: (instant: string) => string;
-    /** Bar content. Default: the title. */
+    /** Bar content. Default: the title. The text is cut at a word, never in one. */
     renderItem?: (item: SchedulingTimelineItem) => ReactNode;
     onSelectItem?: (item: SchedulingTimelineItem) => void;
-    /** Makes bars draggable and keyboard-movable. Receives the snapped new start and end. */
+    /**
+     * Makes bars draggable and keyboard-movable, one call for every key press and every drop.
+     * Receives the snapped new start and end. Not called for moves while `onProposeMove` is set.
+     */
     onMoveItem?: (id: string, next: {
         start: string;
         end: string;
     }) => void;
+    /**
+     * Lets the user ask for a move: a drag, or Shift and an arrow key to build a pending move and
+     * Enter to send it (Escape drops it). Called once per finished gesture. The timeline never
+     * moves the bar: it draws items where the props say, so an item whose props do not change is
+     * back where it was. Return a promise to keep the outline until it settles.
+     */
+    onProposeMove?: (id: string, proposal: MoveProposal) => void | Promise<unknown>;
+    /** Lets Alt+Shift and an arrow key move the end of a bar. Without it there is no resize of any kind. */
+    onResizeItem?: (id: string, next: {
+        start: string;
+        end: string;
+    }) => void;
+    /**
+     * `false` keeps the stacking of bars that share time and drops the hatch and the words for
+     * it: the consumer says what clashes, with a reason, through `markers`. Default `true`.
+     */
+    flagOverlaps?: boolean;
+    /**
+     * Above this many rows only the rows near the viewport are mounted. The rows counted are
+     * the ones passed: `lanes` plus `groups`, whatever is collapsed and however the bars pack, so
+     * the answer does not move with the width. Default 150; `Infinity` mounts everything. It says
+     * when windowing starts, not how much is mounted: that is what the viewport shows, plus overscan.
+     */
+    virtualizeAbove?: number;
+    /** A CSS length. The lanes then scroll inside the timeline under the axis. Unset: the page scrolls. */
+    maxHeight?: string;
+    /** Shown above the axis, e.g. "Showing 500 of 1,240 items". */
+    notice?: ReactNode;
+    /** A note under the axis on the column of a day (`YYYY-MM-DD` in `timeZone`), e.g. a count the consumer knows. */
+    columnNotes?: Record<string, ReactNode>;
     loading?: boolean;
     error?: string;
     onRetry?: () => void;
@@ -100,11 +212,14 @@ interface SchedulingTimelineProps {
     className?: string;
 }
 /**
- * Lanes of bars on a time axis (HAR-1364; TENSOR C8): change schedules, rollout Gantt rows,
- * renewal markers. Overlapping bars in a lane stack and are hatched; freeze, maintenance and
- * blackout windows are bands; with `onMoveItem`, bars move by drag or Shift+arrows and their
- * end changes with Alt+Shift+arrows, snapped to `step`.
+ * Lanes of bars on a time axis (HAR-1364, HAR-1521): schedules by service, rollout rows,
+ * renewal markers. Lanes can sit in collapsible groups; bars that share time stack in sub-rows
+ * packed by `packLanes`; a window is one neutral, patterned element over the lanes it names;
+ * only `band="high"` takes a hue. With `onProposeMove` a move is a proposal handed to the
+ * consumer (drag, or Shift and an arrow key, then Enter); `onMoveItem` still commits every
+ * step; the end of a bar moves only with `onResizeItem`. Long timelines mount only the rows
+ * near the viewport.
  */
-declare function SchedulingTimeline({ lanes, items, range, scale, timeZone, locale, overlays, markers, now, weekStartsOn, tickWidth, step: stepProp, formatTick, formatInstant: formatInstantProp, renderItem, onSelectItem, onMoveItem, loading, error, onRetry, labels: labelOverrides, className, }: SchedulingTimelineProps): react.JSX.Element;
+declare function SchedulingTimeline({ lanes, items, range, scale, timeZone, locale, groups, onToggleGroup, overlays, onSelectOverlay, markers, now, weekStartsOn, tickWidth, step: stepProp, subTicks, formatTick, formatInstant: formatInstantProp, renderItem, onSelectItem, onMoveItem, onProposeMove, onResizeItem, flagOverlaps, virtualizeAbove, maxHeight, notice, columnNotes, loading, error, onRetry, labels: labelOverrides, className, }: SchedulingTimelineProps): react.JSX.Element;
 
-export { DEFAULT_SCHEDULING_TIMELINE_LABELS, SchedulingTimeline, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps };
+export { DEFAULT_SCHEDULING_TIMELINE_LABELS, SchedulingTimeline, type SchedulingTimelineGroup, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps };