@nxgt/material 3.43.0 → 3.45.0

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

@@ -0,0 +1,27 @@
+import { CalendarEvent, EventCalendarResource } from './types.js';
+/** Where a drag ended, once read from the ids of what it was dropped on. */
+export type Drop = {
+    kind: 'time';
+    at: Date;
+} | {
+    kind: 'all-day';
+    day: string;
+} | {
+    kind: 'month';
+    day: string;
+} | {
+    kind: 'event';
+    start: string;
+};
+/**
+ * The event after a drop: moved to the day or time, in the zone when there is
+ * one, and, for a drop on a resource column, assigned to it. Dropped back on
+ * its own column it keeps its `resourceId` as it was.
+ */
+export declare function applyDrop(entry: CalendarEvent, drop: Drop, { zone, resources, target, }: {
+    zone?: string;
+    resources?: EventCalendarResource[];
+    target?: {
+        resourceId?: string | null;
+    };
+}): CalendarEvent;

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

@@ -5,7 +5,14 @@ export declare const RESIZE_PREFIX = "resize:";
 export declare function toDayKey(date: Date): string;
 export declare function parseDayKey(key: string): Date;
 export declare function dayDropId(date: Date): string;
-export declare function allDayDropId(date: Date): string;
-export declare function timeDropId(date: Date): string;
+/** An all-day lane's drop id; a resource's lane adds its id after a `#`, as `timeDropId`. */
+export declare function allDayDropId(date: Date, resourceId?: string | null): string;
+/** A time column's drop id; a resource column adds its id (`''` for the unassigned one) after a `#`. */
+export declare function timeDropId(date: Date, resourceId?: string | null): string;
+/** The day of a time column's or an all-day lane's drop id (what `parsePrefixed` gives, without the resource). */
+export declare function dropDay(rest: string): string;
 export declare function resizeDragId(eventId: string): string;
 export declare function parsePrefixed(id: string, prefix: string): string | null;
+/** The `YYYY-MM-DD` key `days` after `key`. */
+export declare function addKeyDays(key: string, days: number): string;
+export declare function keyDiff(from: string, to: string): number;

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

@@ -0,0 +1,18 @@
+import { Locale } from 'date-fns';
+import { CalendarEvent } from './types.js';
+/**
+ * The times a chip or an agenda row shows. In a zone they are read from the
+ * true instants with the zone's own clock (`wallOf`), never through the
+ * browser's date maths, which would move a wall time its own clock skips.
+ * `drawn` is the event as drawn (the zone's wall clock), `source` as stored.
+ */
+export declare function eventTimes(drawn: CalendarEvent, source: CalendarEvent, zone: string | undefined, format: (value?: string | null, formatStr?: string) => string): {
+    time?: string;
+    endTime?: string;
+};
+/**
+ * The range label of the popover, in the zone: the day is read at noon and
+ * the time on a fixed day, so a wall time the browser's own clock skips never
+ * shifts what is said.
+ */
+export declare function zonedRangeLabel(event: CalendarEvent, locale: Locale, zone: string): string;

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

@@ -0,0 +1,17 @@
+import { DayAxis } from './event-calendar.axis.js';
+import { CalendarEvent, LaidOutEvent } from './types.js';
+/** The shortest an event is drawn, in px: WCAG 2.5.8's 24px target. */
+export declare const MIN_EVENT_HEIGHT = 24;
+/** The minutes an event draws over at least, at `hourHeight` px an hour. */
+export declare function minEventMinutes(hourHeight: number): number;
+/**
+ * Lays the day's timed events out in columns by the time they really take:
+ * events that do not overlap in time share a column and keep the full width.
+ * A short event is drawn at least `minMinutes` long (`MIN_EVENT_HEIGHT`
+ * tall) only into free space: its `drawEndMin` stops at the next event of its
+ * column and never falls under its real end, so back-to-back events sit
+ * flush at their true heights. `axis` (a time zone's day, see `dayAxis`)
+ * replaces the local day: the events are clipped to its window and placed by
+ * its minutes.
+ */
+export declare function layoutTimedEvents(events: CalendarEvent[], day: Date, startHour: number, endHour: number, minMinutes?: number, axis?: DayAxis): LaidOutEvent[];

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

@@ -0,0 +1,36 @@
+import { Tone } from '../../tones.js';
+import { CalendarEvent, EventCalendarResource } from './types.js';
+/** A column of the day view: a resource, or the events that have none (`id` is `null`). */
+export type ResourceColumn = {
+    id: string | null;
+    label: string;
+    description?: string;
+    tone?: Tone;
+};
+/** The id of the resource an event belongs to; `null` when it has none or an unknown one. */
+export declare function resourceKey(event: CalendarEvent, resources: EventCalendarResource[]): string | null;
+/**
+ * The day view's columns: one per resource, in order, behind a leading
+ * "Unassigned" one that exists only while an event has no resource.
+ */
+export declare function resourceColumns(resources: EventCalendarResource[], events: CalendarEvent[], unassignedLabel: string): ResourceColumn[];
+/** The column a phone shows: the one picked, else the first. */
+export declare function shownColumn(columns: ResourceColumn[], picked: string | null): ResourceColumn | undefined;
+/** The events of one column. */
+export declare function eventsOfColumn(events: CalendarEvent[], column: ResourceColumn, resources: EventCalendarResource[]): CalendarEvent[];
+/** The event with its resource set to a column's (the unassigned one clears it). */
+export declare function withColumn(event: CalendarEvent, column: string | null): CalendarEvent;
+/** A React key for a column that no resource id can collide with. */
+export declare function columnKey(column: ResourceColumn): string;
+/** The resource an event belongs to; none when it has none or an unknown one. */
+export declare function ownerOf(event: CalendarEvent, resources?: EventCalendarResource[]): EventCalendarResource | undefined;
+/** The event drawn in its resource's tone when it sets no colour of its own. */
+export declare function withOwnerTone(event: CalendarEvent, owner?: EventCalendarResource): CalendarEvent;
+/**
+ * The column an event is dropped into, or the event itself when it is already
+ * there: an event of an unknown resource, moved inside "Unassigned", keeps
+ * its `resourceId`.
+ */
+export declare function assignColumn(event: CalendarEvent, target: {
+    resourceId?: string | null;
+} | undefined, resources?: EventCalendarResource[]): CalendarEvent;

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

@@ -0,0 +1,7 @@
+import { DayAxis } from './event-calendar.axis.js';
+/**
+ * Minutes from the axis start to the first line labelled `hour` (the wall-clock
+ * hour of the axis, so a day the clocks change opens on the right line), else
+ * counted from `startHour` by the clock.
+ */
+export declare function scrollOffset(axis: DayAxis | undefined, hour: number, startHour: number): number;

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

@@ -7,6 +7,7 @@ export declare const eventCalendarSlice: import('@reduxjs/toolkit').Slice<EventC
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<string | null>) => void;
     setQuery: (state: {
         focusedEventId: string | null;
@@ -14,6 +15,7 @@ export declare const eventCalendarSlice: import('@reduxjs/toolkit').Slice<EventC
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<string>) => void;
     setDirection: (state: {
         focusedEventId: string | null;
@@ -21,6 +23,7 @@ export declare const eventCalendarSlice: import('@reduxjs/toolkit').Slice<EventC
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<-1 | 0 | 1>) => void;
     /** The keyboard moved the cursor: the month view focuses its day. */
     requestDayFocus: (state: {
@@ -29,13 +32,24 @@ export declare const eventCalendarSlice: import('@reduxjs/toolkit').Slice<EventC
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<boolean>) => void;
+    /** The phone's resource switcher picked a column. */
+    setResourceId: (state: {
+        focusedEventId: string | null;
+        query: string;
+        direction: -1 | 0 | 1;
+        viewPicked: boolean;
+        dayFocus: boolean;
+        resourceId: string | null;
+    }, action: PayloadAction<string | null>) => void;
     pickView: (state: {
         focusedEventId: string | null;
         query: string;
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }) => void;
 }, "event-calendar", "event-calendar", import('@reduxjs/toolkit').SliceSelectors<EventCalendarChromeState>>;
 export declare const eventCalendarActions: import('@reduxjs/toolkit').CaseReducerActions<{
@@ -45,6 +59,7 @@ export declare const eventCalendarActions: import('@reduxjs/toolkit').CaseReduce
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<string | null>) => void;
     setQuery: (state: {
         focusedEventId: string | null;
@@ -52,6 +67,7 @@ export declare const eventCalendarActions: import('@reduxjs/toolkit').CaseReduce
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<string>) => void;
     setDirection: (state: {
         focusedEventId: string | null;
@@ -59,6 +75,7 @@ export declare const eventCalendarActions: import('@reduxjs/toolkit').CaseReduce
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<-1 | 0 | 1>) => void;
     /** The keyboard moved the cursor: the month view focuses its day. */
     requestDayFocus: (state: {
@@ -67,12 +84,23 @@ export declare const eventCalendarActions: import('@reduxjs/toolkit').CaseReduce
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }, action: PayloadAction<boolean>) => void;
+    /** The phone's resource switcher picked a column. */
+    setResourceId: (state: {
+        focusedEventId: string | null;
+        query: string;
+        direction: -1 | 0 | 1;
+        viewPicked: boolean;
+        dayFocus: boolean;
+        resourceId: string | null;
+    }, action: PayloadAction<string | null>) => void;
     pickView: (state: {
         focusedEventId: string | null;
         query: string;
         direction: -1 | 0 | 1;
         viewPicked: boolean;
         dayFocus: boolean;
+        resourceId: string | null;
     }) => void;
 }, "event-calendar">;

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

@@ -11,14 +11,11 @@ export declare function shiftCursor(cursor: Date, view: EventCalendarView, delta
 export declare function viewLabel(cursor: Date, view: EventCalendarView, locale?: Locale, weekStartsOn?: WeekStart, short?: boolean): string;
 export declare function weekdayLabels(cursor: Date, locale?: Locale, weekStartsOn?: WeekStart): string[];
 export declare function agendaDays(cursor: Date, count?: number): Date[];
-export declare function hoursList(startHour: number, endHour: number): number[];
 export declare function allDaySlot(day: Date): EventCalendarSlot;
 export declare function allDayRange(from: Date, to: Date): EventCalendarSlot;
 export declare function dayInInclusiveRange(day: Date, from: Date, to: Date): boolean;
-export declare function timedSlot(day: Date, minutes: number, durationMinutes?: number): EventCalendarSlot;
 export declare function eventChanged(a: CalendarEvent, b: CalendarEvent): boolean;
 export declare function matchesEventQuery(event: CalendarEvent, query: string): boolean;
 export declare function eventSpanDays(event: CalendarEvent): number;
 export declare function shiftEvent(event: CalendarEvent, days: number, minutes?: number): CalendarEvent;
-export declare function formatHour(hour: number, locale?: Locale): string;
 export {};

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

@@ -0,0 +1,35 @@
+import { CalendarEvent, EventCalendarSlot } from './types.js';
+/**
+ * The event as the zone's wall clock reads it: `start` and `end` become
+ * offset-less ISO strings (`2026-03-12T09:00:00`), which every day-level
+ * helper of the calendar (the month, the agenda, the lanes, the labels)
+ * reads as plain local fields. The originals stay the source of truth: only
+ * what is drawn is projected, never what is stored or reported.
+ */
+export declare function projectEvent(event: CalendarEvent, timeZone: string): CalendarEvent;
+/** The `YYYY-MM-DD` day an instant falls on in the zone. */
+export declare function zonedDayKey(iso: string, timeZone: string): string;
+/** The event as an all-day one over the zone's day `key`, keeping its span in days. */
+export declare function toZonedAllDay(event: CalendarEvent, key: string, timeZone: string): CalendarEvent;
+/**
+ * The event moved to the zone's day `key`, at the same wall-clock time and
+ * for the same real duration (an all-day one keeps its span in days). A time
+ * the day skips lands the length of the skip later; the first occurrence of a
+ * repeated one is kept unless the event already sits on the second.
+ */
+export declare function moveEventToZonedDay(event: CalendarEvent, key: string, timeZone: string): CalendarEvent;
+/**
+ * The keyboard's move: `days` on the zone's calendar (the wall-clock time is
+ * kept), then `minutes` of real time, on the 15-minute grid.
+ */
+export declare function shiftEventInZone(event: CalendarEvent, days: number, minutes: number, timeZone: string): CalendarEvent;
+/**
+ * An all-day slot the grids built over local days, as the zone's days: the
+ * first instant of the first day to the first instant after the last.
+ */
+export declare function zonedAllDaySlot(slot: EventCalendarSlot, timeZone: string): EventCalendarSlot;
+/**
+ * An `onSlotClick` that tells an all-day slot as the zone's days (its start
+ * and end as that zone's midnights), and leaves the others as they are.
+ */
+export declare function zonedSlotClick(onSlotClick: ((slot: EventCalendarSlot) => void) | undefined, zone: string | undefined): ((slot: EventCalendarSlot) => void) | undefined;

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

@@ -1,5 +1,5 @@
 export type { EventCalendarProps } from './event-calendar.js';
 export { EventCalendar } from './event-calendar.js';
 export { EventCalendarProvider, useEventCalendarContext, } from './event-calendar-context.js';
-export type { CalendarEvent, EventCalendarChange, EventCalendarDensity, EventCalendarRenderEvent, EventCalendarSlot, EventCalendarView, } from './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-event-chip.d.ts

@@ -1,7 +1,9 @@
 import { CalendarEvent } from '../types.js';
-export declare function CalendarEventChip({ event, compact, className, continuesBefore, continuesAfter, appearance, }: {
+export declare function CalendarEventChip({ event: drawn, compact, tight, className, continuesBefore, continuesAfter, appearance, }: {
     event: CalendarEvent;
     compact?: boolean;
+    /** The chip's box is under 20px tall (back-to-back short events). */
+    tight?: boolean;
     className?: string;
     continuesBefore?: boolean;
     continuesAfter?: boolean;

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

@@ -0,0 +1,6 @@
+import { CalendarEvent } from '../types.js';
+/** The popover's Resource select: moves the event to another column (or to none). */
+export declare function EventPreviewResource({ event, locked, }: {
+    event: CalendarEvent;
+    locked: boolean;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,11 @@
+import { CalendarEvent, EventCalendarResource } from '../types.js';
+/**
+ * The popover's first line: the event's colour (its resource's tone when it
+ * sets none), the title to edit in place and the delete button.
+ */
+export declare function EventPreviewTitle({ event, owner, locked, onDelete, }: {
+    event: CalendarEvent;
+    owner?: EventCalendarResource;
+    locked: boolean;
+    onDelete: () => void;
+}): import("react").JSX.Element;

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

@@ -1,4 +1,5 @@
-import { CalendarEvent } from '../types.js';
-export declare function EventPreview({ event }: {
+import { CalendarEvent, EventCalendarResource } from '../types.js';
+export declare function EventPreview({ event, owner, }: {
     event: CalendarEvent;
+    owner?: EventCalendarResource;
 }): import("react").JSX.Element;

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

@@ -1,5 +1,6 @@
+import { DayAxis } from '../event-calendar.axis.js';
 import { CalendarEvent } from '../types.js';
-export declare function EventResizeHandle({ event, day, }: {
+export declare function EventResizeHandle({ event, axis, }: {
     event: CalendarEvent;
-    day: Date;
+    axis: DayAxis;
 }): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/partials/resource-all-day-lane.d.ts

@@ -0,0 +1,6 @@
+import { ResourceColumn } from '../event-calendar.resources.js';
+/** The all-day lane of the day view with `resources`: one lane per resource column, as tall as the fullest. */
+export declare function ResourceAllDayLane({ day, columns, }: {
+    day: Date;
+    columns: ResourceColumn[];
+}): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { ResourceColumn } from '../event-calendar.resources.js';
+/**
+ * The day view's header with `resources`: one cell per resource over its
+ * column, its label and description. It stays above the hours while they
+ * scroll, and the gutter's corner names the zone's offset when there is one.
+ */
+export declare function ResourceHeader({ columns, zoneLabel, zone, }: {
+    columns: ResourceColumn[];
+    zoneLabel?: ReactNode;
+    zone?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { ResourceColumn } from '../event-calendar.resources.js';
+/**
+ * The phone's replacement for the resource columns: one resource shows at a
+ * time, picked here, so no column is squeezed.
+ */
+export declare function ResourceSwitcher({ columns, value, }: {
+    columns: ResourceColumn[];
+    value: ResourceColumn | undefined;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/event-calendar/partials/time-column-now.d.ts

@@ -0,0 +1,10 @@
+import { DayAxis } from '../event-calendar.axis.js';
+/**
+ * The strong now line of today's column. In a zone it sits at the axis'
+ * minute and reads the zone's clock (nothing until the live clock is there);
+ * without one it reads the machine's.
+ */
+export declare function TimeColumnNow({ axis, clock, }: {
+    axis: DayAxis;
+    clock: Date | null;
+}): import("react").JSX.Element | null;

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

@@ -1,3 +1,14 @@
-export declare function TimeColumn({ day }: {
+import { DayAxis } from '../event-calendar.axis.js';
+import { ResourceColumn } from '../event-calendar.resources.js';
+/**
+ * One column of hours: a day, or in the day view with `resources` a resource's
+ * day. `clock` is the live time (null on the server); `showNow` draws the
+ * strong now line in this column.
+ */
+export declare function TimeColumn({ day, axis, resource, clock, showNow, }: {
     day: Date;
+    axis: DayAxis;
+    resource?: ResourceColumn;
+    clock: Date | null;
+    showNow?: boolean;
 }): import("react").JSX.Element;

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

@@ -1,5 +1,9 @@
+import { DayAxis } from '../event-calendar.axis.js';
+import { ResourceColumn } from '../event-calendar.resources.js';
 import { LaidOutEvent } from '../types.js';
-export declare function TimeGridEvent({ laid, day, }: {
+export declare function TimeGridEvent({ laid, axis, resource, }: {
     laid: LaidOutEvent;
-    day: Date;
+    axis: DayAxis;
+    /** The resource column it sits in, in the day view. */
+    resource?: ResourceColumn;
 }): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+/**
+ * One day of the grid's header: the weekday and a large date, today's filled.
+ * With `canOpen` (a week that offers the day view) it is a button that opens
+ * that day.
+ */
+export declare function HeaderDay({ day, canOpen }: {
+    day: Date;
+    canOpen: boolean;
+}): import("react").JSX.Element;

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

@@ -2,6 +2,9 @@
  * The days above the grid: the weekday and a large date, today's filled. In a
  * week, a day opens the day view (when it is offered).
  */
-export declare function TimeGridHeader({ days }: {
+export declare function TimeGridHeader({ days, zoneLabel, zone, }: {
     days: Date[];
+    /** The zone's offset (`UTC+1`), named in the gutter's corner when the calendar has a `timeZone`. */
+    zoneLabel?: string;
+    zone?: string;
 }): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+import { TimeGridState } from '../use-time-grid.js';
+/** The hours of the grid in a scroll area: the gutter, a column per day (or resource) and the now line. */
+export declare function TimeGridHours({ days, grid, }: {
+    days: Date[];
+    grid: TimeGridState;
+}): import("react").JSX.Element;

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

@@ -1,9 +1,16 @@
 /**
  * The week and day views: the days' header, the all-day lane, then the hours
- * in a scroll area — opened on the current time when today is shown, else on
- * `scrollToHour`. The hour height reaches the grid as CSS custom properties
- * set from script, never as inline style in server markup.
+ * in a scroll area (see `useTimeGrid`).
+ *
+ * With `resources` the day view is one column per resource under a sticky
+ * header, scrolling sideways when they do not fit; on a phone one resource
+ * shows at a time. Resources are the day view's only: a week keeps its days.
+ * With a `timeZone` the hours are the zone's: the day view (`real`) draws the
+ * day's real length, 23 or 25 hours on a day the clocks change, while a week
+ * keeps 24 wall-clock rows a day.
  */
-export declare function TimeGrid({ days }: {
+export declare function TimeGrid({ days, real, }: {
     days: Date[];
+    /** Draw each day's real elapsed time in a zone (the day view). */
+    real?: boolean;
 }): import("react").JSX.Element;

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

@@ -1,8 +1,13 @@
+import { AxisTick } from '../event-calendar.axis.js';
 /**
  * The hours beside the grid, each label centred on its line (the first one
- * just below the top). Each row is `--hour-h` tall, as the columns' rows.
+ * just below the top). Each row is `--hour-h` tall, as the columns' rows. The
+ * ticks come from the axis: on a day with a clock change, a label is missing
+ * (the hour skipped) or twice there (the hour repeated).
  */
-export declare function TimeGutter({ nowMinutes, }: {
-    /** The minute of the day the current-time pill sits at, when it shows: the hour under it is hidden. */
-    nowMinutes?: number | null;
+export declare function TimeGutter({ ticks, nowOffset, className, }: {
+    ticks: AxisTick[];
+    /** The minute from the grid's top the current-time pill sits at, when it shows: the hour under it is hidden. */
+    nowOffset?: number | null;
+    className?: string;
 }): import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { Tone } from '../../../tones.js';
+/** A resource's tone as a small dot: decorative, its name is next to it. */
+export declare function ToneMark({ tone }: {
+    tone: Tone;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+/**
+ * The gutter's corner above the hours: it names the zone's offset (`UTC+1`)
+ * when the calendar has a `timeZone`, and stays an empty cell otherwise.
+ */
+export declare function ZoneCorner({ zoneLabel, zone, className, }: {
+    zoneLabel?: ReactNode;
+    zone?: string;
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -1,5 +1,6 @@
 import { ReactNode } from 'react';
 import { EventChipVariant } from '../../display/event-chip/event-chip.classes.js';
+import { Tone } from '../../tones.js';
 export type EventCalendarView = 'month' | 'week' | 'workweek' | 'day' | 'agenda';
 export type CalendarEvent = {
     id: string;
@@ -10,6 +11,24 @@ export type CalendarEvent = {
     color?: string;
     description?: string;
     disabled?: boolean;
+    /**
+     * The `id` of the resource (a room, a person, a team) the event belongs to,
+     * when the calendar has `resources`. One with none, or an unknown one, is
+     * unassigned.
+     */
+    resourceId?: string;
+};
+/** A column of the day view: a room, a person, a team. */
+export type EventCalendarResource = {
+    id: string;
+    label: string;
+    description?: string;
+    /**
+     * A tone of the library (`'success'`, or one an app declared), never a raw
+     * colour. A small mark on the column's header and on the phone switcher
+     * shows it, and it is the colour of the column's events that set none.
+     */
+    tone?: Tone;
 };
 export type EventCalendarChange = {
     events: CalendarEvent[];
@@ -20,6 +39,8 @@ export type EventCalendarSlot = {
     start: Date;
     end: Date;
     allDay: boolean;
+    /** The resource column a timed slot or an all-day slot was made in, in the day view. */
+    resourceId?: string;
 };
 /** `comfortable` (the default) or `compact`: shorter hours and month cells. */
 export type EventCalendarDensity = 'comfortable' | 'compact';
@@ -32,6 +53,8 @@ export type EventCalendarChromeState = {
     viewPicked: boolean;
     /** The keyboard moved the cursor: its day takes the focus once rendered. */
     dayFocus: boolean;
+    /** The resource the phone's switcher shows; `null` is the first. */
+    resourceId: string | null;
 };
 export type EventCalendarRenderEvent = (event: CalendarEvent) => ReactNode;
 export type EventCalendarProps = {
@@ -76,6 +99,23 @@ export type EventCalendarProps = {
     now?: Date;
     /** The hour the week and day views open on when today is not shown. Default 7. */
     scrollToHour?: number;
+    /**
+     * The columns of the day view, one per resource, under a sticky header.
+     * Events go in the column of their `resourceId`; those with none (or an
+     * unknown one) share a leading "Unassigned" column, drawn only when one
+     * exists. Dragging an event to another column changes its `resourceId`
+     * through `onChange`. On a phone one resource shows at a time, picked in a
+     * switcher. The week, workweek, month and agenda views ignore it.
+     */
+    resources?: EventCalendarResource[];
+    /**
+     * An IANA zone (`Africa/Lagos`) to read the calendar in. The grid, "today",
+     * the day boundaries, the now line and the times shown follow it;
+     * `start` and `end` stay true instants, and so do the dates given to
+     * `onSlotClick` and `onChange`. An unknown name reads `UTC` (a warning in
+     * development). Without it, the machine's clock.
+     */
+    timeZone?: string;
 };
 export type LaidOutEvent = {
     event: CalendarEvent;
@@ -83,4 +123,6 @@ export type LaidOutEvent = {
     columns: number;
     startMin: number;
     endMin: number;
+    /** Where it is drawn to: `endMin`, or further into free space up to the minimum height. */
+    drawEndMin: number;
 };

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

@@ -0,0 +1,3 @@
+import { DragEndEvent } from '@dnd-kit/core';
+/** The `onDragEnd` of the board: reads what was dropped where, and replaces the event. */
+export declare function useCalendarDrag(): (event: DragEndEvent) => void;

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

@@ -0,0 +1,3 @@
+import { KeyboardEvent } from 'react';
+/** The board's `onKeyDown`: the arrows shift the period or the focused event. */
+export declare function useCalendarKeys(): (event: KeyboardEvent<HTMLDivElement>) => void;

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

@@ -0,0 +1,15 @@
+import { EventCalendarProps, EventCalendarView } from './types.js';
+/**
+ * The view and the day the calendar shows, each controlled or not. Choosing a
+ * view by hand (`onPickView`) stops the phone's own view from taking over.
+ */
+export declare function useCalendarNav({ view: viewProp, defaultView, onViewChange, date: dateProp, defaultDate, onDateChange, onPickView, }: Pick<EventCalendarProps, 'view' | 'defaultView' | 'onViewChange' | 'date' | 'onDateChange'> & {
+    defaultDate: string;
+    onPickView: () => void;
+}): {
+    view: EventCalendarView;
+    cursor: string;
+    cursorDate: Date;
+    setView: (next: EventCalendarView) => void;
+    setCursor: (next: string) => void;
+};

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

@@ -0,0 +1,13 @@
+import { CalendarEvent } from './types.js';
+/**
+ * What a chip shows of the event drawn (the zone's wall clock when the
+ * calendar has a `timeZone`): the event as stored (the one callbacks get), its
+ * resource, the event in that resource's tone, and its times read in the zone.
+ */
+export declare function useChipEvent(drawn: CalendarEvent): {
+    time?: string;
+    endTime?: string;
+    source: CalendarEvent;
+    owner: import('./types.js').EventCalendarResource | undefined;
+    event: CalendarEvent;
+};

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

@@ -0,0 +1,9 @@
+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[];
+};