@nxgt/material 3.80.0 → 3.81.0

package/dist/lib/components/ui/fields/repeatable-group/partials/repeatable-group-row.d.ts

@@ -12,6 +12,8 @@ export type RepeatableGroupRowProps = {
     reorderable?: boolean;
     /** `min` is not reached yet. */
     removable: boolean;
+    /** Not rendered (`removeAtMin: 'hide'` at `min`). */
+    hideRemove?: boolean;
     /** `removable` said this row cannot go. */
     locked?: boolean;
     lockedReason?: string;
@@ -20,4 +22,4 @@ export type RepeatableGroupRowProps = {
     onMove: (direction: 'up' | 'down') => void;
 };
 /** One row: its fields, then its move buttons (when reorderable) and Remove. */
-export declare function RepeatableGroupRow({ index, count, children, names, reorderable, removable, locked, lockedReason, disabled, onRemove, onMove, }: RepeatableGroupRowProps): import("react").JSX.Element;
+export declare function RepeatableGroupRow({ index, count, children, names, reorderable, removable, hideRemove, locked, lockedReason, disabled, onRemove, onMove, }: RepeatableGroupRowProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/repeatable-group/partials/repeatable-group-rows.d.ts

@@ -8,6 +8,7 @@ export type RepeatableGroupRowsProps<TItem> = {
     names: RepeatableGroupRowProps['names'];
     reorderable: boolean;
     min?: number;
+    removeAtMin?: RepeatableGroupProps<TItem>['removeAtMin'];
     removable?: RepeatableGroupProps<TItem>['removable'];
     removeDisabledReason?: RepeatableGroupProps<TItem>['removeDisabledReason'];
     disabled?: boolean;
@@ -20,4 +21,4 @@ export type RepeatableGroupRowsProps<TItem> = {
  * The rows as a list (`ul` / `li`; the group around it carries the name),
  * or, with no row, the empty state when it has a title.
  */
-export declare function RepeatableGroupRows<TItem>({ items, getKey, renderRow, names, reorderable, min, removable, removeDisabledReason, disabled, onRemove, onMove, emptyTitle, emptyDescription, }: RepeatableGroupRowsProps<TItem>): import("react").JSX.Element | null;
+export declare function RepeatableGroupRows<TItem>({ items, getKey, renderRow, names, reorderable, min, removeAtMin, removable, removeDisabledReason, disabled, onRemove, onMove, emptyTitle, emptyDescription, }: RepeatableGroupRowsProps<TItem>): import("react").JSX.Element | null;

package/dist/lib/components/ui/fields/repeatable-group/repeatable-group.d.ts

@@ -9,4 +9,4 @@ export type { RepeatableGroupProps, RepeatableGroupRowContext, } from './types.j
  * politely. For react-hook-form, `RepeatableGroupFormField` wires it to
  * `useFieldArray`.
  */
-export declare function RepeatableGroup<TItem>({ items, renderRow, getKey, label, rowLabel, addLabel, onAdd, onRemove, onMove, reorderable, min, max, removable, removeDisabledReason, disabled, error, emptyTitle, emptyDescription, className, ref, ...props }: RepeatableGroupProps<TItem>): import("react").JSX.Element;
+export declare function RepeatableGroup<TItem>({ items, renderRow, getKey, label, rowLabel, addLabel, onAdd, onRemove, onMove, reorderable, min, removeAtMin, max, removable, removeDisabledReason, disabled, error, emptyTitle, emptyDescription, className, ref, ...props }: RepeatableGroupProps<TItem>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/repeatable-group/types.d.ts

@@ -34,6 +34,13 @@ export type RepeatableGroupProps<TItem> = Omit<ComponentProps<'div'>, 'children'
     reorderable?: boolean;
     /** No Remove at this many rows. */
     min?: number;
+    /**
+     * What a row's Remove button does at `min` rows: `'disable'` (default)
+     * keeps it, disabled; `'hide'` does not render it, so a form whose only
+     * row cannot go shows no dead control. A row `removable` refuses keeps its
+     * Remove button (with its reason) either way.
+     */
+    removeAtMin?: 'disable' | 'hide';
     /**
      * Whether a row can be removed. A row that cannot keeps its Remove button
      * `aria-disabled` (still focusable; activating it does nothing). Default: every row can (`min` still

package/dist/lib/components/ui/media/galleries/gallery.d.ts

@@ -1,3 +1,3 @@
 import { GalleryProps } from './types.js';
 export type { GalleryItem, GalleryProps } from './types.js';
-export declare function Gallery({ className, ...props }: GalleryProps): import("react").JSX.Element;
+export declare function Gallery(props: GalleryProps): import("react").JSX.Element;

package/dist/lib/components/ui/media/galleries/lightbox-gallery.d.ts

@@ -1,6 +1,6 @@
 import { GalleryItem, GalleryProps } from './types.js';
 export type LightboxGalleryItem = GalleryItem;
-export type LightboxGalleryProps = Pick<GalleryProps, 'items' | 'className' | 'onDelete' | 'open' | 'onOpenChange' | 'trigger' | 'defaultIndex'> & {
+export type LightboxGalleryProps = Pick<GalleryProps, 'items' | 'className' | 'aria-label' | 'aria-labelledby' | 'onDelete' | 'open' | 'onOpenChange' | 'trigger' | 'defaultIndex'> & {
     startIndex?: number;
 };
 export declare function LightboxGallery({ startIndex, defaultIndex, ...props }: LightboxGalleryProps): import("react").JSX.Element;

package/dist/lib/components/ui/media/galleries/mini-gallery.d.ts

@@ -1,4 +1,4 @@
 import { GalleryItem, GalleryProps } from './types.js';
 export type MiniGalleryItem = GalleryItem;
-export type MiniGalleryProps = Pick<GalleryProps, 'items' | 'className' | 'onDelete' | 'maxItems'>;
+export type MiniGalleryProps = Pick<GalleryProps, 'items' | 'className' | 'aria-label' | 'aria-labelledby' | 'onDelete' | 'maxItems'>;
 export declare function MiniGallery(props: MiniGalleryProps): import("react").JSX.Element;

package/dist/lib/components/ui/overlays/dialog/dialog-parts.d.ts

@@ -3,7 +3,7 @@ import { ComponentProps } from 'react';
 declare function DialogHeader({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
 declare function DialogFooter({ className, stackOnPhone, ...props }: ComponentProps<'div'> & {
     /**
-     * Phones: the actions stack, full width, the main one at the bottom (the
+     * Phones: the actions stack, full width, the last-written (main) one on top (the
      * default). `false` keeps one row, the first action on the left and the
      * last on the right, for two short actions such as Cancel and Confirm.
      */

package/dist/lib/components/ui/overlays/sheet/sheet-parts.d.ts

@@ -1,6 +1,11 @@
 import { Dialog as SheetPrimitive } from 'radix-ui';
 import { ComponentProps } from 'react';
 declare function SheetHeader({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+/**
+ * Full-width actions in a column, in the same phone order as `DialogFooter`:
+ * write them in reading order (secondary first, main last) and the main one
+ * is on top, the secondary below it.
+ */
 declare function SheetFooter({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
 declare function SheetTitle({ className, ...props }: ComponentProps<typeof SheetPrimitive.Title>): import("react").JSX.Element;
 declare function SheetDescription({ className, ...props }: ComponentProps<typeof SheetPrimitive.Description>): import("react").JSX.Element;

package/dist/lib/components/ui/selection/choice-card-group/choice-card-balance.d.ts

@@ -0,0 +1,4 @@
+/** The columns drawn when `fit` columns fit, for `count` cards. */
+export declare function balancedColumns(count: number, fit: number): number;
+/** One column below two cards' width, then the balanced count at each width that fits more. */
+export declare function balancedGridClasses(count: number, columns: 1 | 2 | 3 | 4): string[];

package/dist/lib/components/ui/selection/choice-card-group/choice-card-group.d.ts

@@ -7,6 +7,8 @@ export type { ChoiceCardGroupProps, ChoiceCardOption };
  * Space toggles). Enter does nothing, so it never submits a form. A disabled
  * option, or any unchosen one once `max` is reached, stays focusable and
  * says why. The cards sit in up to `columns` columns, each at least 13.5rem wide
- * (one on a phone); `orientation="vertical"` makes it one. The `ref` reaches the card that holds the tab stop.
+ * (one on a phone), and balanced: the last row is never one orphan card when a
+ * nearby count avoids it (4 cards in room for 3 sit 2+2); `balance={false}`
+ * fills every column that fits. `orientation="vertical"` makes it one. The `ref` reaches the card that holds the tab stop.
  */
 export declare function ChoiceCardGroup(props: ChoiceCardGroupProps): import("react").JSX.Element;

package/dist/lib/components/ui/selection/choice-card-group/choice-card-group.types.d.ts

@@ -15,5 +15,12 @@ export type ChoiceCardGroupProps = ChoiceGroupBase & ChoiceSelection & {
      * Default 2. `orientation="vertical"` makes it one.
      */
     columns?: 1 | 2 | 3 | 4;
+    /**
+     * Balance the rows: when the cards would leave one alone on the last row
+     * (4 cards in room for 3), draw fewer columns instead (2+2). Default
+     * `true`; `false` fills every column that fits, as before. CSS only,
+     * from the group's own width.
+     */
+    balance?: boolean;
     density?: 'comfortable' | 'compact';
 };

package/dist/lib/components/ui/selection/sortable-list/partials/sortable-list-body.d.ts

@@ -1,4 +1,8 @@
-/** The listbox: its keys, its rows (or the empty state). */
+/**
+ * The list: its keys, its rows (or the empty state). A row holds buttons of
+ * its own, so it is a list item, not an option; the focus moves from row to
+ * row (a roving tab stop) and the keys act only when a row itself has it.
+ */
 export declare function SortableListBody({ emptyTitle }: {
     emptyTitle: string;
 }): import("react").JSX.Element;

package/dist/lib/components/ui/selection/sortable-list/partials/sortable-list-row-parts.d.ts

@@ -1,7 +1,8 @@
 import { SortableListLabels } from '../sortable-list-context.js';
 import { SortableListDragActivator, SortableListItem } from '../types.js';
 /** The row's start mark: a lock, the drag handle, or an empty slot. */
-export declare function SortableListGrip({ locked, canDrag, activator, labels, }: {
+export declare function SortableListGrip({ locked, canDrag, activator, labels, itemLabel, }: {
+    itemLabel?: string;
     locked?: boolean;
     canDrag: boolean;
     activator: SortableListDragActivator;

package/dist/lib/components/ui/selection/sortable-list/partials/sortable-list-row-props.d.ts

@@ -10,19 +10,22 @@ type RowProps = {
     focused: boolean;
     grabbed: boolean;
     setFocused: (value: string | null) => void;
+    /** The row that holds the list's one tab stop. */
+    tabbable: boolean;
 };
-/** The option semantics of a row, over the props the sortable hands it. */
-export declare function sortableRowProps({ domProps, id, style, dragging, item, disabled, focused, grabbed, setFocused, }: RowProps): {
+/** The list item semantics of a row, over the props the sortable hands it. */
+export declare function sortableRowProps({ domProps, id, style, dragging, item, disabled, focused, grabbed, setFocused, tabbable, }: RowProps): {
     readonly 'aria-roledescription': undefined;
     readonly 'aria-describedby': undefined;
     readonly 'aria-pressed': undefined;
     readonly id: string;
     readonly style: CSSProperties | undefined;
-    readonly role: "option";
-    readonly 'aria-selected': boolean;
+    readonly role: "listitem";
+    readonly 'aria-selected': undefined;
     readonly 'aria-disabled': true | undefined;
     readonly 'data-grabbed': true | undefined;
-    readonly tabIndex: -1;
+    readonly 'data-disabled': true | undefined;
+    readonly tabIndex: 0 | -1;
     readonly onFocus: () => void;
     readonly ref: (node: HTMLDivElement | null) => void;
     readonly title?: string | undefined;

package/dist/lib/components/ui/selection/sortable-list/partials/use-owed-focus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A key moved the cursor, the order or the rows: the focus is still owed to
+ * the list's tab stop once React has committed (a reorder re-inserts the row
+ * and the browser drops its focus to the body). `arm` records the debt for
+ * that key's commit only.
+ */
+export declare function useOwedFocus(focusedValue: string | null | undefined, ids: string[]): {
+    listRef: import('react').RefObject<HTMLDivElement | null>;
+    arm: (commandType: string) => void;
+};

package/dist/lib/components/ui/selection/sortable-list/sortable-list-context.d.ts

@@ -28,3 +28,5 @@ export type SortableListContextValue = {
 export declare const SortableListProvider: import('react').Provider<SortableListContextValue | null>;
 export declare function useSortableListContext(): SortableListContextValue;
 export declare function sortableOptionId(uid: string, index: number): string;
+/** The id of the hidden "This field is required." hint that describes the list. */
+export declare function sortableRequiredId(uid: string): string;

package/dist/lib/components/ui/selection/sortable-list/sortable-list.keyboard.d.ts

@@ -20,7 +20,7 @@ type KeyEventLike = {
     preventDefault: () => void;
 };
 /**
- * The listbox's keys. Arrows move the cursor, Home / End jump; Ctrl/⌘ +
+ * The list's keys. Arrows move the cursor, Home / End jump; Ctrl/⌘ +
  * arrow moves the row at once. Space or Enter picks a row up: then arrows
  * move it, Space or Enter drops it, Escape puts it back. Delete removes it
  * when the list is `removable`.

package/dist/lib/components/ui/widgets/event-calendar/event-calendar-context.d.ts

@@ -1,10 +1,13 @@
 import { ReactNode } from 'react';
 import { EventChipVariant } from '../../display/event-chip/event-chip.classes.js';
+import { TemplateContext } from './template.types.js';
 import { CalendarEvent, EventCalendarRenderEvent, EventCalendarSlot, EventCalendarView } from './types.js';
 import { EventCalendarModel } from './use-event-calendar.js';
 export type EventCalendarContextValue = EventCalendarModel & {
     /** The events as stored, true instants; `events` is what is drawn (the zone's wall clock). */
     sourceEvents?: CalendarEvent[];
+    /** Set in `mode="template"`: the lanes, and the lane of each event. */
+    template?: TemplateContext;
     dragLabel: string;
     searchable: boolean;
     /** The views the switcher offers. */

package/dist/lib/components/ui/widgets/event-calendar/event-calendar-shell.d.ts

@@ -0,0 +1,15 @@
+import { TemplateContext } from './template.types.js';
+import { CalendarEvent, EventCalendarProps } from './types.js';
+/** What only the template mode passes down to the shared calendar. */
+export type EventCalendarShellProps = EventCalendarProps & {
+    template?: TemplateContext;
+    /** Hides the events it rejects (the template's lane), on top of the search. */
+    visible?: (event: CalendarEvent) => boolean;
+};
+/**
+ * A month / week / workweek / day / agenda calendar: drag to move, the bottom
+ * edge to resize, click or drag across empty slots to create, a now line, a
+ * mini-month side panel and a phone layout of its own. Events are props; the
+ * chrome (search, focus, the last move's direction) lives in a slice.
+ */
+export declare function EventCalendarShell({ template, visible, onEventClick, onSlotClick, className, renderEvent, toolbar, searchable, views, phoneView, sidebar, eventVariant, scrollToHour, ...options }: EventCalendarShellProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/event-calendar-template.d.ts

@@ -0,0 +1,9 @@
+import { EventCalendarTemplateProps } from './template.types.js';
+/**
+ * `<EventCalendar mode="template">`: the recurring week. It runs the dated
+ * calendar on a fixed reference week and keeps the dates out of sight (see
+ * `event-calendar.template.ts`): the column headers are weekday names, the
+ * toolbar has no date navigation, nothing is today, and what comes out of
+ * `onSlotClick`, `onChange` and `onEventsChange` is weekday and time.
+ */
+export declare function TemplateEventCalendar(props: EventCalendarTemplateProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/event-calendar.d.ts

@@ -1,9 +1,13 @@
+import { EventCalendarTemplateProps } from './template.types.js';
 import { EventCalendarProps } from './types.js';
 export type { EventCalendarProps } from './types.js';
 /**
  * A month / week / workweek / day / agenda calendar: drag to move, the bottom
  * edge to resize, click or drag across empty slots to create, a now line, a
- * mini-month side panel and a phone layout of its own. Events are props; the
- * chrome (search, focus, the last move's direction) lives in a slice.
+ * mini-month side panel and a phone layout of its own.
+ *
+ * With `mode="template"` it is a recurring week instead: columns named by
+ * weekday, no dates, events keyed by weekday and time, and optional `lanes`
+ * (A / B) for two alternating weeks. See `EventCalendarTemplateProps`.
  */
-export declare function EventCalendar({ onEventClick, onSlotClick, className, renderEvent, toolbar, searchable, views, phoneView, sidebar, eventVariant, scrollToHour, ...options }: EventCalendarProps): import("react").JSX.Element;
+export declare function EventCalendar(props: EventCalendarProps | EventCalendarTemplateProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/event-calendar.template.d.ts

@@ -0,0 +1,41 @@
+import { Locale } from 'date-fns';
+import { EventCalendarTemplateEvent, EventCalendarTemplateSlot, TemplateContext } from './template.types.js';
+import { CalendarEvent, EventCalendarSlot } from './types.js';
+/**
+ * The template week is drawn on a fixed reference week, Monday 2001-01-01 to
+ * Sunday 2001-01-07: the dated grid, drag and resize work on it unchanged, and
+ * only the weekday and the time ever leave the calendar.
+ */
+export declare const REFERENCE_MONDAY = "2001-01-01";
+/** A moment outside the reference week: no column is "today", no now line. */
+export declare const TEMPLATE_NOW: Date;
+/** The reference week's days, Monday first (`count` 5: Monday to Friday). */
+export declare function referenceDays(count?: number): Date[];
+export declare function parseClock(time: string): number;
+export declare function formatClock(minutes: number): string;
+/** The template event as a dated one on the reference week. */
+export declare function toDatedEvent(event: EventCalendarTemplateEvent): CalendarEvent;
+/**
+ * The dated event back as the template event it came from (`base` keeps what
+ * the calendar does not edit, such as the lane).
+ */
+export declare function fromDatedEvent(event: CalendarEvent, base?: EventCalendarTemplateEvent): EventCalendarTemplateEvent;
+/** A slot of the dated grid as weekday and time. */
+export declare function toTemplateSlot(slot: EventCalendarSlot, lane: string | null): EventCalendarTemplateSlot;
+/** Whether a lane filter keeps the event: no lane means every week. */
+export declare function inLane(laneOfEvent: string | undefined, lane: string | null): boolean;
+/** `Monday · 8:00 AM – 9:00 AM`: the popover's range, with no date. */
+export declare function templateRangeLabel(event: CalendarEvent, locale?: Locale): string;
+/**
+ * The title a chip draws: with both weeks showing, an event of a lane says
+ * which (`A · Physics`); otherwise the title as it is.
+ */
+export declare function laneTitle(event: CalendarEvent, template: TemplateContext | undefined): string;
+/** A weekday moved by `days`, wrapped within the visible `count` days (5: Monday to Friday, 7: the week). */
+export declare function wrapWeekday(weekday: number, days: number, count: number): number;
+/**
+ * The dated event moved by `days` and `minutes` inside the template week: the
+ * weekday wraps within the visible days, and the move stops at the day's
+ * edges (00:00 and 24:00) keeping the duration.
+ */
+export declare function moveTemplateEvent(event: CalendarEvent, days: number, minutes: number, count: number): CalendarEvent;

package/dist/lib/components/ui/widgets/event-calendar/index.d.ts

@@ -1,5 +1,6 @@
 export type { EventCalendarProps } from './event-calendar.js';
 export { EventCalendar } from './event-calendar.js';
 export { EventCalendarProvider, useEventCalendarContext, } from './event-calendar-context.js';
+export type { EventCalendarLane, EventCalendarTemplateChange, EventCalendarTemplateEvent, EventCalendarTemplateProps, EventCalendarTemplateSlot, EventCalendarWeekday, } from './template.types.js';
 export type { CalendarEvent, EventCalendarChange, EventCalendarDensity, EventCalendarRenderEvent, EventCalendarResource, EventCalendarSlot, EventCalendarView, } from './types.js';
 export { useEventCalendar } from './use-event-calendar.js';

package/dist/lib/components/ui/widgets/event-calendar/partials/calendar-date-nav.d.ts

@@ -0,0 +1,2 @@
+/** Today, the arrows and the period: the dated calendar's navigation. */
+export declare function CalendarDateNav(): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/partials/calendar-lane-toggle.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The template week's lane switch (`All`, `A`, `B`): which alternating week
+ * shows. An event with no lane shows in every one. Nothing without `lanes`.
+ */
+export declare function CalendarLaneToggle(): import("react").JSX.Element | null;

package/dist/lib/components/ui/widgets/event-calendar/partials/time-grid-header-template.d.ts

@@ -0,0 +1,7 @@
+/**
+ * One day of a template week's header: the weekday's name and nothing else
+ * (a letter on a phone, the short name from 768px, the full name from 1024px).
+ */
+export declare function TemplateHeaderDay({ day }: {
+    day: Date;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/template.types.d.ts

@@ -0,0 +1,73 @@
+import { ReactNode } from 'react';
+import { EventCalendarProps } from './types.js';
+/** ISO weekday: 1 is Monday, 7 is Sunday. */
+export type EventCalendarWeekday = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+/**
+ * An event of a template week: keyed by weekday and wall-clock time instead of
+ * a date. `start` and `end` are `HH:mm` (`end` may be `24:00`, the day's end).
+ */
+export type EventCalendarTemplateEvent = {
+    id: string;
+    title: string;
+    weekday: EventCalendarWeekday;
+    start: string;
+    end: string;
+    /** The alternating week it belongs to (an `EventCalendarLane` id); none: every week. */
+    lane?: string;
+    color?: string;
+    description?: string;
+    disabled?: boolean;
+};
+/** An alternating week of the template (`A`, `B`). */
+export type EventCalendarLane = {
+    id: string;
+    label: string;
+};
+export type EventCalendarTemplateSlot = {
+    weekday: EventCalendarWeekday;
+    start: string;
+    end: string;
+    /** The lane picked in the toolbar, when one is (none while both show). */
+    lane?: string;
+};
+export type EventCalendarTemplateChange = {
+    events: EventCalendarTemplateEvent[];
+    event: EventCalendarTemplateEvent;
+    previous: EventCalendarTemplateEvent;
+};
+/**
+ * `mode="template"`: a recurring week. Day columns are named by weekday only,
+ * there is no date navigation, today marker or now line, and events,
+ * slots and changes are keyed by weekday and time. The month, day and agenda
+ * views do not apply: `view` is `week` (the default) or `workweek`.
+ */
+export type EventCalendarTemplateProps = Pick<EventCalendarProps, 'disabled' | 'className' | 'toolbar' | 'searchable' | 'density' | 'eventVariant' | 'startHour' | 'endHour' | 'hourHeight' | 'slotDurationMinutes' | 'scrollToHour'> & {
+    mode: 'template';
+    events?: EventCalendarTemplateEvent[];
+    defaultEvents?: EventCalendarTemplateEvent[];
+    onEventsChange?: (events: EventCalendarTemplateEvent[]) => void;
+    /** After a move, a resize or an edit, with the previous event. */
+    onChange?: (change: EventCalendarTemplateChange) => void;
+    onEventClick?: (event: EventCalendarTemplateEvent) => void;
+    /** A click or a drag across an empty slot: where, as weekday and time. */
+    onSlotClick?: (slot: EventCalendarTemplateSlot) => void;
+    /** `week` (7 days, the default) or `workweek` (Monday to Friday). */
+    view?: 'week' | 'workweek';
+    defaultView?: 'week' | 'workweek';
+    onViewChange?: (view: 'week' | 'workweek') => void;
+    /** The alternating weeks (`[{ id: 'A', label: 'Week A' }, …]`); a toolbar switch picks which shows. */
+    lanes?: EventCalendarLane[];
+    /** The lane shown: an id, or `null` for all. Default (uncontrolled): all. */
+    lane?: string | null;
+    defaultLane?: string | null;
+    onLaneChange?: (lane: string | null) => void;
+    /** Replaces how an event is drawn. */
+    renderEvent?: (event: EventCalendarTemplateEvent) => ReactNode;
+};
+/** What the template mode hands the shared internals through the context. */
+export type TemplateContext = {
+    lanes: EventCalendarLane[];
+    lane: string | null;
+    setLane: (lane: string | null) => void;
+    laneOf: (eventId: string) => string | undefined;
+};

package/dist/lib/components/ui/widgets/event-calendar/types.d.ts

@@ -58,6 +58,8 @@ export type EventCalendarChromeState = {
 };
 export type EventCalendarRenderEvent = (event: CalendarEvent) => ReactNode;
 export type EventCalendarProps = {
+    /** `dated` (the default): real dates. See `mode="template"` for a recurring week. */
+    mode?: 'dated';
     events?: CalendarEvent[];
     defaultEvents?: CalendarEvent[];
     onEventsChange?: (events: CalendarEvent[]) => void;

package/dist/lib/components/ui/widgets/event-calendar/use-chip-event.d.ts

@@ -10,4 +10,5 @@ export declare function useChipEvent(drawn: CalendarEvent): {
     source: CalendarEvent;
     owner: import('./types.js').EventCalendarResource | undefined;
     event: CalendarEvent;
+    title: string;
 };

package/dist/lib/components/ui/widgets/event-calendar/use-drawn-events.d.ts

@@ -1,9 +1,10 @@
+import { CalendarEvent } from './types.js';
 import { EventCalendarModel } from './use-event-calendar.js';
 /**
  * The events the search keeps, as stored (true instants), and as drawn: in a
  * zone, the zone's wall clock; otherwise the same list.
  */
-export declare function useDrawnEvents({ events, chrome, zone, project, }: EventCalendarModel): {
-    sourceEvents: import('./types.js').CalendarEvent[];
-    visibleEvents: import('./types.js').CalendarEvent[];
+export declare function useDrawnEvents({ events, chrome, zone, project }: EventCalendarModel, visible?: (event: CalendarEvent) => boolean): {
+    sourceEvents: CalendarEvent[];
+    visibleEvents: CalendarEvent[];
 };

package/dist/lib/components/ui/widgets/event-calendar/use-template-calendar.d.ts

@@ -0,0 +1,18 @@
+import { EventCalendarTemplateEvent, EventCalendarTemplateProps, TemplateContext } from './template.types.js';
+import { CalendarEvent, EventCalendarChange, EventCalendarSlot } from './types.js';
+/**
+ * The template week as the dated calendar reads it: the events (controlled or
+ * not) on the reference week, the lane filter, and the callbacks turned back
+ * into weekday and time. The dated calendar owns no copy: the list given
+ * is always the template list, mapped.
+ */
+export declare function useTemplateCalendar({ events, defaultEvents, onEventsChange, onChange, onEventClick, onSlotClick, lanes, lane: laneProp, defaultLane, onLaneChange, }: EventCalendarTemplateProps): {
+    dated: CalendarEvent[];
+    back: (event: CalendarEvent) => EventCalendarTemplateEvent;
+    template: TemplateContext;
+    visible: (event: CalendarEvent) => boolean;
+    onEventsChange: (next: CalendarEvent[]) => void;
+    onChange: ((change: EventCalendarChange) => void) | undefined;
+    onEventClick: ((event: CalendarEvent) => void) | undefined;
+    onSlotClick: ((slot: EventCalendarSlot) => void) | undefined;
+};

package/dist/lib/components/ui/widgets/event-calendar/use-template-lane.d.ts

@@ -0,0 +1,17 @@
+import { EventCalendarTemplateEvent } from './template.types.js';
+import { CalendarEvent } from './types.js';
+/**
+ * The template week's lane filter: the lane shown (controlled or not), its
+ * setter, and whether a dated event belongs to it (an event with no lane
+ * shows in every one).
+ */
+export declare function useTemplateLane({ lane: laneProp, defaultLane, onLaneChange, byId, }: {
+    lane?: string | null;
+    defaultLane?: string | null;
+    onLaneChange?: (lane: string | null) => void;
+    byId: Map<string, EventCalendarTemplateEvent>;
+}): {
+    lane: string | null;
+    setLane: (next: string | null) => void;
+    visible: (event: CalendarEvent) => boolean;
+};

package/dist/lib/hooks/index.d.ts

@@ -16,6 +16,7 @@ export * from './use-options.js';
 export * from './use-react-router-block.js';
 export * from './use-scroll-away.js';
 export * from './use-search-param.js';
+export * from './use-ssr-media-query.js';
 export * from './use-submit-once.js';
 export * from './use-theme.js';
 export * from './use-unsaved-guard/index.js';

package/dist/lib/i18n/resources/en/en.d.ts

@@ -1817,6 +1817,8 @@ export declare const en: {
             sidebar: string;
             unassigned: string;
             resource: string;
+            lane: string;
+            "lane-all": string;
             "time-zone": string;
         };
         dnd: {

package/dist/lib/i18n/resources/en/material.json.d.ts

@@ -1807,6 +1807,8 @@ declare const _default: {
 		"sidebar": "Calendar navigation",
 		"unassigned": "Unassigned",
 		"resource": "Resource",
+		"lane": "Week",
+		"lane-all": "All weeks",
 		"time-zone": "Time zone: {zone}"
 	},
 	"dnd": {

package/dist/lib/i18n/resources/fr/fr.d.ts

@@ -1817,6 +1817,8 @@ export declare const fr: {
             sidebar: string;
             unassigned: string;
             resource: string;
+            lane: string;
+            "lane-all": string;
             "time-zone": string;
         };
         dnd: {

package/dist/lib/i18n/resources/fr/material.json.d.ts

@@ -1807,6 +1807,8 @@ declare const _default: {
 		"sidebar": "Navigation du calendrier",
 		"unassigned": "Non assigné",
 		"resource": "Ressource",
+		"lane": "Semaine",
+		"lane-all": "Toutes les semaines",
 		"time-zone": "Fuseau horaire : {zone}"
 	},
 	"dnd": {

package/dist/lib/i18n/resources/resources.d.ts

@@ -1815,6 +1815,8 @@ export declare const resources: {
                 sidebar: string;
                 unassigned: string;
                 resource: string;
+                lane: string;
+                "lane-all": string;
                 "time-zone": string;
             };
             dnd: {
@@ -5329,6 +5331,8 @@ export declare const resources: {
                 sidebar: string;
                 unassigned: string;
                 resource: string;
+                lane: string;
+                "lane-all": string;
                 "time-zone": string;
             };
             dnd: {