@k2b/ui 0.22.0 → 0.23.0

package/dist/types/content/Calendar.d.ts

@@ -26,6 +26,11 @@ export type CalendarEvent = {
      * a priority flag in custom `renderEvent` content.
      */
     accessibleDetail?: string;
+    /**
+     * Day and week views with `dayHours`: the state of the entry's checkbox, such as a to-do's. Leave it out for entries
+     * without one. With `onEventCheck` the reader can change it.
+     */
+    checked?: boolean;
     location?: string;
     calendarName?: string;
     attendees?: CalendarAttendee[];
@@ -66,6 +71,59 @@ export type CalendarEventRenderContext = {
     timeLabel: string;
     /** Month view: the start time to show before the title of a one-day timed entry; absent on bars and elsewhere. */
     leadingTime?: string;
+    /** Day and week views: what is left of the event that is running now, such as "27 min left". */
+    remaining?: string;
+    /** Day and week views: the calendar draws the event's checkbox beside this content, so leave yours out. */
+    checkbox?: boolean;
+    /**
+     * Day and week views with `dayHours`: the event is a band, a deadline, or an all-day entry of a timeline. Render the
+     * title in `k2b-calendar-event__title` and the time in `k2b-calendar-event__meta` there, so the views size them.
+     */
+    timeline?: boolean;
+};
+/** The days a host loaded events for, from the first day `from` up to `to`, both `YYYY-MM-DD` or dates. */
+export type CalendarRange = {
+    from: Date | string;
+    to: Date | string;
+};
+/**
+ * An action the calendar offers for keyboard shortcuts, the command palette, and its shortcuts dialog. The calendar
+ * publishes its own through `onCommandsChange`; the host registers them with its shortcut dispatcher.
+ */
+export type CalendarCommand = {
+    /** Unique on the page, such as `calendar.today`. */
+    id: string;
+    label: string;
+    /** One key combination: a key such as `h`, or modifiers and a key such as `shift+n`. */
+    shortcut?: string;
+    /** One sentence for the command palette and the help, such as "Show today in the calendar". */
+    description?: string;
+    icon?: string;
+    run: () => void;
+};
+/** An entry dragged into the day or week view from outside the calendar, such as a task from a list below it. */
+export type CalendarExternalDrag = {
+    title: string;
+    color?: CalendarEventColor;
+    colorHex?: string;
+    /** The length it gets in the calendar. */
+    minutes: number;
+};
+/** Actions of the calendar that the host starts from its own controls. */
+export type CalendarController = {
+    /**
+     * Opens the quick create at the selection, or where a new entry fits: today at the next full hour while today is
+     * shown, else at 09:00 of the first shown day. `create` reaches `renderQuickCreate` as in the month view's menu.
+     */
+    quickCreate: (create?: string) => void;
+    /** The time a new entry takes, by the rule of `quickCreate`; all-day for days selected in the month view. */
+    createTarget: () => CalendarEventTimeChange;
+    /**
+     * Day and week views with `dayHours`: follows a pointer that pressed an entry outside the calendar, shows where it
+     * would go and whether it fits the free time there, and calls `onDrop` with the time where it is released. Escape
+     * or a release outside the days cancels.
+     */
+    dragIn: (event: PointerEvent, item: CalendarExternalDrag, onDrop: (slot: CalendarEventTimeChange) => void) => void;
 };
 /** A view the application adds to the switcher; the calendar shows its header and toolbar, the application the body. */
 export type CalendarCustomView<V extends string = string> = {
@@ -90,6 +148,24 @@ export type CalendarProps<V extends string = never> = {
     withWeekNumbers?: boolean;
     startHour?: number;
     endHour?: number;
+    /**
+     * Waking hours `[start, end]` of the day and week views, such as `[6, 22]`. With them, a day runs from `start` to
+     * `start` of the next day, so the night after `end` belongs to the day before. The day view becomes one stream of
+     * days down the page and the week view a strip of days to scroll sideways; nights fold unless an entry lies in them.
+     * `startHour`, `endHour`, and the visible hours do not apply then.
+     */
+    dayHours?: readonly [start: number, end: number];
+    /** Day and week views with `dayHours`: the days of `events`. Without it they cover the day or week of `date`. */
+    range?: CalendarRange;
+    /** Called once when the reader nears the first loaded day, again once `range.from` moved. */
+    onLoadEarlier?: () => unknown;
+    /** Called once when the reader nears the last loaded day, again once `range.to` moved. */
+    onLoadLater?: () => unknown;
+    /**
+     * Day and week views with `dayHours`: the first and the last day the reader sees, once the view opened and whenever
+     * scrolling changed them, such as for the URL or a count of what is in view.
+     */
+    onVisibleDateChange?: (date: Date, last: Date) => void;
     visibleStartHour?: number;
     visibleEndHour?: number;
     allDayMaxHeightRem?: number;
@@ -117,6 +193,11 @@ export type CalendarProps<V extends string = never> = {
     onEventDrop?: (event: CalendarEvent, next: CalendarEventTimeChange) => void;
     onEventResize?: (event: CalendarEvent, next: CalendarEventTimeChange) => void;
     onSlotActivate?: (slot: CalendarEventTimeChange) => void;
+    /**
+     * Changes the checkbox of an entry with `checked`; leave it out when the reader may not change it. The box shows the
+     * change at once; a returned promise that rejects puts it back.
+     */
+    onEventCheck?: (event: CalendarEvent, checked: boolean) => void | Promise<unknown>;
     /** Pointer gesture used for empty slots. Keyboard activation is always immediate. */
     slotActivation?: "single" | "double";
     /**
@@ -140,6 +221,16 @@ export type CalendarProps<V extends string = never> = {
     toolbarActions?: JSX.Element;
     /** Application controls, such as filters, right after the period title. */
     toolbarContent?: JSX.Element;
+    /** The application's own commands, such as New event, listed after the calendar's in its shortcuts dialog. */
+    commands?: readonly CalendarCommand[];
+    /**
+     * Receives the calendar's commands and `commands` whenever they change, to register them with the host's shortcut
+     * dispatcher: Today (H), Next (J) and Previous (K), the views (1 to 4), and Go to (G). The calendar then also offers
+     * its shortcuts dialog. Without a dispatcher the commands have no keys.
+     */
+    onCommandsChange?: (commands: readonly CalendarCommand[]) => void;
+    /** Receives the calendar's controller once it mounts. */
+    controller?: (controller: CalendarController) => void;
     class?: string;
 };
 export type CalendarSelectionControls = {

package/dist/types/content/CalendarDayView.d.ts

@@ -0,0 +1,7 @@
+import { type TimeViewProps } from "./calendar-time-view";
+/**
+ * The day view with `dayHours`: the loaded days one below the other in a single scroll, each with its heading kept on
+ * top while it is in view. Runs of empty days fold into one row. The view slows down and settles at each day start,
+ * and a line at the top of the heading fills while a day start passes.
+ */
+export declare const CalendarDayView: (props: TimeViewProps) => import("solid-js").JSX.Element;

package/dist/types/content/CalendarWeekView.d.ts

@@ -0,0 +1,7 @@
+import { type TimeViewProps } from "./calendar-time-view";
+/**
+ * The week view with `dayHours`: the loaded days side by side in one strip, seven on a wide screen and three on a
+ * phone. A trackpad, Shift with the wheel, or a finger scroll it sideways day by day; each gesture keeps the axis it
+ * started on, and the strip settles on a day start. The arrows move by whole weeks.
+ */
+export declare const CalendarWeekView: (props: TimeViewProps) => import("solid-js").JSX.Element;

package/dist/types/content/ChartExplorer.d.ts

@@ -8,19 +8,47 @@ export type ChartExplorerColumn<T> = {
     value: (row: T) => string;
     /** Optional table cell presentation; value remains the plain text used for copy/details. */
     render?: (row: T) => JSX.Element;
-    /** Explicit comparable value. Omit to leave the column unsortable. */
+    /**
+     * Explicit comparable value. Omit to leave the column unsortable.
+     * Returning a number also exempts the cell from spreadsheet formula guarding on copy.
+     */
     sortValue?: (row: T) => string | number | null;
     align?: "left" | "center" | "right";
 };
+/** One legend entry; `color` is the palette index the renderer gave the series (0 is `--stdlib-chart-c1`). */
+export type ChartLegendEntry = {
+    label: string;
+    color: number;
+    /** Line pattern of a line series; a solid series shows a filled swatch. */
+    style?: "solid" | "dashed" | "dotted";
+    /** A comparison series, drawn hollow like its marks. */
+    reference?: boolean;
+};
 export type ChartExplorerProps<T extends ChartExplorerRow> = {
     cursor?: ChartCursor;
     title: string;
+    /** Level of the title heading. Defaults to 3; a chart inside a titled group of charts sits one level below it. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
     description?: JSX.Element;
     data: ChartExplorerData<T>;
     columns: readonly ChartExplorerColumn<T>[];
     view?: "chart" | "table";
     defaultView?: "chart" | "table";
     onViewChange?: (view: "chart" | "table") => void;
+    /**
+     * Several charts of the same rows. The switcher then lists each chart and the table; `chart` names the one `data`
+     * holds, and `onChartChange` reports a pick, so the owner passes the matching data.
+     */
+    charts?: readonly {
+        id: string;
+        label: string;
+    }[];
+    chart?: string;
+    onChartChange?: (id: string) => void;
+    /** Filter controls between the header and the viewport, such as ChartFilterControls. */
+    controls?: JSX.Element;
+    /** The table renders at most this many rows of the sorted order; sorting and Copy data use every row. */
+    tableRows?: number;
     sort?: DataTableSort | null;
     defaultSort?: DataTableSort | null;
     onSortChange?: (sort: DataTableSort | null) => void;
@@ -29,6 +57,13 @@ export type ChartExplorerProps<T extends ChartExplorerRow> = {
     /** false hides the complete local detail area for a shared selection panel. */
     renderDetails?: false | ((row: T) => JSX.Element);
     height?: string;
+    /**
+     * Series names below the chart, wrapping inside the fixed viewport height. Use it instead of the renderer's legend,
+     * which draws in one row and runs out of narrow columns.
+     */
+    legend?: readonly ChartLegendEntry[];
+    /** What the viewport shows without rows, for example while they load; defaults to "No data". */
+    empty?: JSX.Element;
     class?: string;
 };
 export declare function ChartExplorer<T extends ChartExplorerRow>(props: ChartExplorerProps<T>): JSX.Element;

package/dist/types/content/ChartFilterControls.d.ts

@@ -6,12 +6,17 @@ export type ChartFilterControlsProps = {
         key: string;
         label: string;
     }[];
+    /** Series to filter; `color` shows a swatch and belongs only to series the chart colors that way. */
     series?: readonly {
         key: string;
         label: string;
-        color: string;
+        color?: string;
     }[];
     dimensionLabel?: string;
+    /** Label of the series filter, such as the column the series come from; defaults to the inherited series label. */
+    seriesLabel?: string;
+    /** Offer pinning the current step as a reference for comparison. */
+    compare?: boolean;
     disabled?: boolean;
     failed?: boolean;
     onRequest: (request: ChartExplorerRequest) => void;

package/dist/types/content/DataTable.d.ts

@@ -58,6 +58,11 @@ export type DataTableProps<T> = {
      * server-rendered: sorting is a query change, not client state.
      */
     sortHref?: (next: DataTableSort) => string;
+    /**
+     * Sorts on the client instead: sortable headers become buttons that report the
+     * next order, with the same look and order of directions as `sortHref`.
+     */
+    onSortChange?: (next: DataTableSort) => void;
     selectedRowId?: string | null;
     /** Optional multi-selection shared with another collection view. Requires getRowId. */
     selection?: CollectionSelection;

package/dist/types/content/calendar-day-scroll.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Scroll rules of the day and week views, free of the DOM so they can be tested.
+ *
+ * The day view runs down through the days and stops gently at each day start: within `STOP_ZONE` pixels of one the
+ * wheel slows down, and a scroll that rests close to one glides onto it. The week view scrolls sideways through the
+ * days; a wheel or trackpad gesture keeps the axis it started on, and a scroll that rests between two days glides to
+ * the nearer day.
+ */
+/** Pixels before and after a day start in which the wheel slows down. */
+export declare const STOP_ZONE = 72;
+/** How much of a wheel step remains right at a day start. */
+export declare const STOP_MIN_FACTOR = 0.16;
+/** A resting scroll this close to a day start glides onto it: a wheel or trackpad, and a finger that flings further. */
+export declare const SETTLE_RADIUS: {
+    readonly wheel: 40;
+    readonly touch: 88;
+};
+/** A pause between wheel events that starts a new gesture. */
+export declare const GESTURE_GAP_MS = 150;
+/** A wheel delta in pixels, whatever unit the browser reports it in. */
+export declare const wheelPixels: (delta: number, mode: number, page: number) => number;
+/** The index of the last stop at or before a position; `stops` are sorted. */
+export declare const stopIndexAt: (stops: readonly number[], position: number) => number;
+export declare const nearestStop: (stops: readonly number[], position: number) => number | undefined;
+/** How much of a wheel step moves the view at a position: less the closer it is to a stop, eased. */
+export declare const stopFactor: (stops: readonly number[], position: number) => number;
+/**
+ * Where a wheel step of `delta` pixels takes the view, braked near stops, or `undefined` when no stop lies within
+ * reach and the browser scrolls as usual. The first stop at 0 brakes nothing: there is no day before it to leave.
+ */
+export declare const brakedScroll: (stops: readonly number[], position: number, delta: number) => number | undefined;
+/** The stop a resting scroll glides onto, or `undefined` when it rests on one or too far from any. */
+export declare const settleTarget: (stops: readonly number[], position: number, radius: number) => number | undefined;
+/** How far a header has crossed its stop, 0 to 1, for the line that fills while a day start passes. */
+export declare const stopCrossing: (stop: number, position: number) => number;
+export type WheelAxis = "x" | "y";
+/** The axis a wheel gesture takes from its first event: Shift turns a vertical wheel sideways. */
+export declare const wheelAxis: (deltaX: number, deltaY: number, shiftKey: boolean) => WheelAxis;
+/** The sideways part of a wheel event on an axis, Shift turning the vertical delta into a sideways one. */
+export declare const wheelDelta: (axis: WheelAxis, deltaX: number, deltaY: number, shiftKey: boolean) => number;
+/** The scroll position of the nearest day start in a strip of equal columns. */
+export declare const snapToColumn: (position: number, width: number) => number;

package/dist/types/content/calendar-days.d.ts

@@ -0,0 +1,192 @@
+import { type DateContext } from "@k2b/stdlib";
+/**
+ * The time model of the day and week views with `dayHours`: a day runs from its start hour to the same hour of the next
+ * day, so the night after the waking hours belongs to the day before it. Every place in a day is a count of minutes on
+ * the wall clock after that start, which keeps a day 24 hours long on the clock across a change to or from summer
+ * time. Timed events over calendar dates go to the all-day row, unless they end by the next day's start hour.
+ * An event that crosses only the day start stays bands in both days. The functions here are pure and work on
+ * `YYYY-MM-DD` day keys in the calendar's time zone.
+ */
+/** Waking hours: `start` begins the day, `end` begins its night, which lasts until `start` of the next day. */
+export type CalendarDayHours = readonly [start: number, end: number];
+export declare const DAY_MINUTES = 1440;
+/** Free time from this length on is labelled, such as "1 hr free"; shorter gaps show only while dragging into them. */
+export declare const GAP_LABEL_MINUTES = 60;
+/** Free time from this length on stands out. */
+export declare const GAP_LONG_MINUTES = 180;
+/** Days since 1970-01-01 of a `YYYY-MM-DD` key; day keys need no time zone for this. */
+export declare const dayKeyNumber: (key: string) => number;
+export declare const keyOfDayNumber: (value: number) => string;
+export declare const addDayKeys: (key: string, days: number) => string;
+/** Every key from `first` to `last`, both included. */
+export declare const dayKeyRange: (first: string, last: string) => string[];
+/** The wall clock of an instant in the calendar's time zone, as `YYYY-MM-DDTHH:mm`. */
+export declare const wallClock: (instant: Date, context?: DateContext) => string;
+/** The instant of a wall clock in the calendar's time zone; a time a clock change skips moves forward, as clocks do. */
+export declare const wallInstant: (wall: string, context?: DateContext) => Date;
+/** Minutes on the wall clock from the start of the day `key` to the instant; negative before it, above 1440 after it. */
+export declare const minuteInDay: (key: string, instant: Date, hours: CalendarDayHours, context?: DateContext) => number;
+/** The instant at a minute of the day `key`. */
+export declare const instantInDay: (key: string, minute: number, hours: CalendarDayHours, context?: DateContext) => Date;
+/**
+ * The instants of a slot of the day `key`. A time the change to summer time skips moves forward, so a slot drawn there
+ * could end at or before its start; it then keeps the length it was drawn with.
+ */
+export declare const instantsInDay: (key: string, start: number, end: number, hours: CalendarDayHours, context?: DateContext) => {
+    start: Date;
+    end: Date;
+};
+/**
+ * An entry with one edge dragged to a minute of the day `key`, given as the slot `minutes` it now spans there. The
+ * other edge keeps its instant, so an entry in the hour a change from summer time repeats keeps its real time; the
+ * entry never ends before it starts.
+ */
+export declare const resizedInDay: (entry: {
+    start: Date;
+    end: Date;
+}, edge: "start" | "end", key: string, minutes: {
+    start: number;
+    end: number;
+}, hours: CalendarDayHours, context?: DateContext) => {
+    start: Date;
+    end: Date;
+};
+/** The day an instant belongs to: before the start hour it is still the night of the day before. */
+export declare const dayKeyOf: (instant: Date, hours: CalendarDayHours, context?: DateContext) => string;
+/** The wall-clock time `HH:mm` at a minute of a day. */
+export declare const clockAt: (minute: number, hours: CalendarDayHours) => string;
+/** Minutes of the waking hours, from the start of the day to the start of its night. */
+export declare const wakeMinutes: (hours: CalendarDayHours) => number;
+/** One entry the views place: a timed event, an all-day event, or a point in time such as a deadline. */
+export type DayEntry<T> = {
+    item: T;
+    start: Date;
+    /** For all-day entries the midnight after their last day. */
+    end: Date;
+    allDay: boolean;
+    /** A point in time at `start`; an all-day point is due on its day. */
+    marker: boolean;
+};
+/** A timed entry of one day, in minutes of that day. */
+export type DayBand<T> = {
+    item: T;
+    start: number;
+    end: number;
+};
+export type DayMarker<T> = {
+    item: T;
+    minute: number;
+};
+/**
+ * An entry of the all-day row: all-day events, points due on a day, and timed events over calendar dates, ignoring
+ * the end date when the event ends by its day start. Events crossing only the day start stay bands in both days.
+ */
+export type DaySpan<T> = {
+    item: T;
+    firstKey: string;
+    lastKey: string;
+    marker: boolean;
+};
+export type DayModel<T> = {
+    key: string;
+    bands: DayBand<T>[];
+    markers: DayMarker<T>[];
+    spans: DaySpan<T>[];
+    /** Something lies in the night, so it opens by default. */
+    night: boolean;
+    empty: boolean;
+};
+/** Where an entry goes: the timelines of the days it touches, or the all-day row over its calendar dates. */
+export declare const placeEntry: <T>(entry: DayEntry<T>, hours: CalendarDayHours, context?: DateContext) => {
+    kind: "band";
+    bands: {
+        key: string;
+        band: DayBand<T>;
+    }[];
+} | {
+    kind: "marker";
+    key: string;
+    marker: DayMarker<T>;
+} | {
+    kind: "span";
+    span: DaySpan<T>;
+};
+/** The model of each day from `first` to `last`. */
+export declare const buildDays: <T>(first: string, last: string, entries: readonly DayEntry<T>[], hours: CalendarDayHours, context?: DateContext) => Map<string, DayModel<T>>;
+export type DayGap = {
+    start: number;
+    end: number;
+    past: boolean;
+};
+/**
+ * Free time of a day's waking hours between its timed entries. `now` is the current minute of this day, `Infinity`
+ * for a day that is over, and `-Infinity` for one still ahead. The gap that holds now starts at the next quarter hour.
+ */
+export declare const freeGaps: <T>(bands: readonly DayBand<T>[], wake: number, now: number, minimum?: number) => DayGap[];
+/**
+ * What activating free time creates: a gap up to two hours whole, a longer one an hour from its start. A gap from the
+ * start of the day that leaves room proposes 09:00, so "16 hrs free" never becomes a 16-hour event.
+ */
+export declare const gapProposal: (gap: Pick<DayGap, "start" | "end">, hours: CalendarDayHours) => [start: number, end: number];
+export type DayLane<T> = DayBand<T> & {
+    lane: number;
+    lanes: number;
+};
+/** Overlapping bands side by side; a band counts at least `minimum` minutes long, as its drawn height does. */
+export declare const dayLanes: <T>(bands: readonly DayBand<T>[], minimum: number) => DayLane<T>[];
+/** About the minutes a deadline's pill covers in the waking hours; the open night is half as tall, so twice as many. */
+export declare const MARKER_MINUTES = 30;
+/**
+ * Deadlines whose pills would cover each other side by side, in time order from the left; each line stays at its own
+ * minute. Two to-dos due at the same time, such as Spaces' default 17:00, so both keep their title and checkbox.
+ */
+export declare const markerLanes: <T>(markers: readonly DayMarker<T>[], wake: number) => import("./calendar-event-layout").CalendarIntervalLayout<DayMarker<T>>[];
+export type DayGroup = {
+    kind: "day";
+    key: string;
+} | {
+    kind: "empty";
+    keys: string[];
+};
+/**
+ * The days of the stream: each day with something in it alone, runs of empty days as one. The days in `keep`, such
+ * as today, the day the reader opened, and every day of a run the reader unfolded, never fold, so days that load
+ * next to an unfolded run fold on their own and leave it open.
+ */
+export declare const dayGroups: (keys: readonly string[], empty: (key: string) => boolean, keep: ReadonlySet<string>) => DayGroup[];
+/** Pixel sizes of a day's timeline: waking hours at full height, the night at half, below a bar or folded into a row. */
+export type DayGeometry = {
+    hour: number;
+    nightHour: number;
+    nightBar: number;
+    fold: number;
+    wake: number;
+    expanded: boolean;
+};
+/** The top of a minute. */
+export declare const dayY: (geometry: DayGeometry, minute: number) => number;
+/** The top of something that starts at a minute: from the start of the night on, below the night's bar. */
+export declare const dayTopY: (geometry: DayGeometry, minute: number) => number;
+/** The minute at a height, the inverse of `dayY`; the night's bar and a folded night map to the start of the night. */
+export declare const dayMinuteAt: (geometry: DayGeometry, y: number) => number;
+export declare const dayHeight: (geometry: DayGeometry) => number;
+/** The last minute the timeline draws: the end of the night when it is open, else the start of the night. */
+export declare const dayLimit: (geometry: DayGeometry) => number;
+/** Rounds to the step, the 15 or 5 minutes a pointer snaps to. */
+export declare const snapMinutes: (minute: number, step: number) => number;
+/**
+ * A height in a day's timeline as counts of the four sizes the stylesheet sets: waking hours, night hours, the night's
+ * bar, and the folded night row. The views draw with these, so a phone's smaller hours need no script.
+ */
+export type DayTerms = readonly [hours: number, nightHours: number, nightBars: number, folds: number];
+/** `dayY` as terms. */
+export declare const dayYTerms: (wake: number, expanded: boolean, minute: number) => DayTerms;
+/** `dayTopY` as terms. */
+export declare const dayTopTerms: (wake: number, expanded: boolean, minute: number) => DayTerms;
+/** `dayHeight` as terms. */
+export declare const dayHeightTerms: (wake: number, expanded: boolean) => DayTerms;
+export declare const subtractTerms: (left: DayTerms, right: DayTerms) => DayTerms;
+/** Terms as a CSS length over the sizes of the stylesheet. */
+export declare const termsCss: (terms: DayTerms) => string;
+/** The pixel sizes of the terms where an element draws its timeline, for pointer positions. */
+export declare const readDayGeometry: (element: Element, wake: number, expanded: boolean) => DayGeometry;

package/dist/types/content/calendar-dialogs.d.ts

@@ -0,0 +1,22 @@
+import type { CalendarCommand } from "./Calendar";
+import type { CalendarMessages } from "./calendar-messages";
+/** The keys of a shortcut as the reader presses them, such as ["⇧", "N"] or ["Shift", "N"]. */
+export declare const shortcutKeys: (shortcut: string) => string[];
+/**
+ * The calendar's shortcuts: the same list the host registers for its dispatcher and its help. `alternatives` names
+ * other keys the calendar itself handles for a command, such as the arrow keys that page like J and K.
+ */
+export declare const openCalendarShortcuts: (commands: readonly CalendarCommand[], messages: CalendarMessages, alternatives?: Readonly<Record<string, string>>) => Promise<void | undefined>;
+/**
+ * Reads German and English dates, weekdays, months, week numbers, today, and tomorrow for Go to. Weekdays include
+ * today unless preceded by next; a month alone uses the next year if it has passed. A date without a year is this
+ * year's. Names ignore case and accents and allow a trailing dot. Returns a `YYYY-MM-DD` key or `null`.
+ */
+export declare const parseGoTo: (text: string, today: string) => string | null;
+/** Go to: a field that reads a date or a week number and names the day it found before the reader goes there. */
+export declare const openCalendarGoTo: (props: {
+    messages: CalendarMessages;
+    today: string;
+    describe: (key: string) => string;
+    onGo: (key: string) => void;
+}) => Promise<void>;

package/dist/types/content/calendar-messages.d.ts

@@ -52,6 +52,105 @@ declare const calendarMessages: import("@k2b/stdlib").Catalog<{
         day: number;
         month?: string;
     }) => string;
+    calendarDuration: ({ minutes }: {
+        minutes: number;
+    }) => string;
+    calendarFree: ({ duration }: {
+        duration: string;
+    }) => string;
+    calendarCreateAt: ({ start, end }: {
+        start: string;
+        end: string;
+    }) => string;
+    calendarFreeAction: ({ duration, from, to, start, end, }: {
+        duration: string;
+        from: string;
+        to: string;
+        start: string;
+        end: string;
+    }) => string;
+    calendarRemaining: ({ duration }: {
+        duration: string;
+    }) => string;
+    calendarSoon: ({ title, duration }: {
+        title: string;
+        duration: string;
+    }) => string;
+    calendarNight: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    calendarNightHours: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    calendarFoldNight: string;
+    calendarOpenNight: string;
+    calendarFoldNights: string;
+    calendarOpenNights: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+    calendarUntil: ({ time }: {
+        time: string;
+    }) => string;
+    calendarNothingPlannedShort: string;
+    calendarUnfoldDays: ({ count }: {
+        count: number;
+    }) => string;
+    calendarDayCount: ({ count }: {
+        count: number;
+    }) => string;
+    calendarDaySummary: ({ events, tasks }: {
+        events: number;
+        tasks: number;
+    }) => string;
+    calendarMoreDays: string;
+    calendarAllDayRow: string;
+    calendarAllDayRowShort: string;
+    calendarAllDayAndDue: string;
+    calendarDone: ({ title }: {
+        title: string;
+    }) => string;
+    calendarAllDone: string;
+    calendarAllDoneShort: string;
+    calendarDue: ({ time }: {
+        time: string;
+    }) => string;
+    calendarFits: string;
+    calendarTooShort: ({ duration }: {
+        duration: string;
+    }) => string;
+    calendarOverlaps: ({ title }: {
+        title: string;
+    }) => string;
+    calendarWeekNumber: ({ week }: {
+        week: number;
+    }) => string;
+    calendarWeek: string;
+    calendarDays: string;
+    calendarKeyboardHelp: string;
+    calendarDayKeyboardHelp: string;
+    calendarShortcuts: string;
+    calendarShortcutsNote: string;
+    calendarCommandToday: string;
+    calendarCommandTodayDescription: string;
+    calendarCommandNext: string;
+    calendarCommandNextDescription: string;
+    calendarCommandPrevious: string;
+    calendarCommandPreviousDescription: string;
+    calendarCommandView: ({ view }: {
+        view: string;
+    }) => string;
+    calendarCommandViewDescription: ({ view }: {
+        view: string;
+    }) => string;
+    calendarCommandGoTo: string;
+    calendarCommandGoToDescription: string;
+    calendarGoToPlaceholder: string;
+    calendarGoToHint: string;
+    calendarGoToUnknown: string;
+    calendarGoToGo: string;
 }>;
 export type CalendarMessages = ReturnType<(typeof calendarMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale, like the rest of @k2b/ui. */

package/dist/types/content/calendar-pointer.d.ts

@@ -10,8 +10,17 @@ type CalendarPointerSessionOptions<T> = {
     onPreview: (value: T) => void;
     onCommit: (value: T) => void;
     onCancel?: () => void;
+    /** Called once whenever the session ends, even before activation, after onCommit or onCancel. */
+    onEnd?: () => void;
     scrollContainer?: HTMLElement;
     threshold?: number;
+    /**
+     * The edges scroll only once the pointer has been well inside the container, and only while it is over it, so a drag
+     * that comes in from outside, such as from a list below, does not scroll on its way in.
+     */
+    armAutoScroll?: boolean;
+    /** Called on every move once the gesture is active, such as to move a token with the pointer. */
+    onMove?: (clientX: number, clientY: number) => void;
 };
 /**
  * Owns one pointer gesture from threshold crossing through commit or cancel.