@slotted/angular 0.0.0-stage → 0.1.0-beta.0

package/types/slotted-angular-event-calendar.d.ts

@@ -0,0 +1,574 @@
+import { PlainTime, PlainDate, PlainDateTime } from '@slotted/core/date';
+import * as _slotted_core_event_calendar from '@slotted/core/event-calendar';
+import { EventCalendarListRange, EventCalendarWeekends, EventOccurrence, EventCalendarView, CalendarEvent, EventCalendarCalendar, WorkingHours, EventPlacement } from '@slotted/core/event-calendar';
+export { CalendarEvent, EventCalendarCalendar, EventCalendarListRange, EventCalendarView, EventCalendarWeekends, EventOccurrence, WorkingHours } from '@slotted/core/event-calendar';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, EventCalendarMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, OnInit } from '@angular/core';
+import { ChangeRequest, ChangeReason } from '@slotted/core/state';
+
+/**
+ * What the reader chose to act on: a run of days, the last one inclusive, or a
+ * stretch of one day's hours, the end exclusive — the two ends a calendar's
+ * events already have.
+ */
+type EventCalendarSelection = {
+    readonly start: PlainDate;
+    readonly end: PlainDate;
+} | {
+    readonly start: PlainDateTime;
+    readonly end: PlainDateTime;
+};
+type EventCalendarSelectionMode = 'none' | 'range';
+/** What happens to the month and the week below the compact size class. */
+type EventCalendarCompact = 'list' | 'keep';
+type EventCalendarHourCycle = 'h12' | 'h23';
+/**
+ * Where the reader asked an occurrence to go: dates with the last day
+ * inclusive for an all-day event, date-times with the end exclusive for a
+ * timed one — what the application writes back into the event. `occurrence`
+ * is the date the occurrence stood on, which is what an application moving
+ * one occurrence of a series writes as its `occurrence`.
+ */
+type EventCalendarEventChange = {
+    readonly key: string;
+    readonly event: CalendarEvent;
+    readonly occurrence: PlainDate;
+    readonly recurring: boolean;
+    readonly kind: 'move' | 'resize';
+} & ({
+    readonly start: PlainDate;
+    readonly end: PlainDate;
+} | {
+    readonly start: PlainDateTime;
+    readonly end: PlainDateTime;
+});
+/** The period in view, emitted after it changes so an application can fetch it. */
+interface EventCalendarRange {
+    readonly start: PlainDate;
+    /** The last day drawn, inclusive. */
+    readonly end: PlainDate;
+    readonly view: EventCalendarView;
+}
+/** What an application sets once for every event calendar under it. */
+interface EventCalendarDefaults {
+    compact: EventCalendarCompact;
+    dayHours: readonly [number, number];
+    firstDayOfWeek: number | undefined;
+    fixedWeeks: boolean;
+    hourCycle: EventCalendarHourCycle | undefined;
+    listRange: EventCalendarListRange;
+    loadingDelay: number;
+    loadingMinDuration: number;
+    maxColumns: number;
+    maxEvents: number;
+    scrollTime: PlainTime;
+    /** Minutes, 5 to 120: the lighter rules and the step of a selection or a drag. */
+    slotDuration: number;
+    timeZone: string | undefined;
+    weekends: EventCalendarWeekends;
+    weekNumbers: boolean;
+}
+declare const EVENT_CALENDAR_FALLBACK: EventCalendarDefaults;
+declare const EVENT_CALENDAR_DEFAULTS: InjectionToken<EventCalendarDefaults>;
+/**
+ * An application decides once which zone answers "today", when its working
+ * day starts and how tall an hour is. The locale and the words come from the
+ * language in force (`provideSlotted`).
+ */
+declare function provideEventCalendarDefaults(defaults: Partial<EventCalendarDefaults>): {
+    provide: InjectionToken<EventCalendarDefaults>;
+    useFactory: () => EventCalendarDefaults;
+};
+declare function injectEventCalendarDefaults(): EventCalendarDefaults;
+/** What `ng-template[slEventCalendarEvent]` receives. */
+interface EventCalendarEventContext {
+    readonly $implicit: EventOccurrence;
+    readonly layout: 'lane' | 'bar' | 'block' | 'list';
+    readonly date: PlainDate;
+    /** The time the family would write, for a template that keeps it. */
+    readonly time: string | null;
+}
+/** What `ng-template[slEventCalendarDetail]` receives. */
+interface EventCalendarDetailContext {
+    readonly $implicit: EventOccurrence;
+    /** Asks to close the detail, with the reason `programmatic`. */
+    readonly close: () => void;
+}
+/**
+ * What a secondary click, a long press or `Shift+F10` pointed at: an event,
+ * or a stretch of the grid — the selection when the pointer was inside it,
+ * otherwise one step of the hours or one day.
+ */
+type EventCalendarContextTarget = {
+    readonly kind: 'event';
+    readonly occurrence: EventOccurrence;
+} | {
+    readonly kind: 'slot';
+    readonly slot: EventCalendarSelection;
+};
+/** What `ng-template[slEventCalendarContextMenu]` receives. */
+interface EventCalendarContextMenuContext {
+    readonly $implicit: EventCalendarContextTarget;
+}
+/** What `ng-template[slEventCalendarDayContent]` receives. */
+interface EventCalendarDayContentContext {
+    readonly $implicit: PlainDate;
+    readonly view: EventCalendarView;
+}
+
+type EventLayout = 'lane' | 'bar' | 'block' | 'list';
+interface EventView {
+    readonly key: string;
+    readonly occurrence: EventOccurrence;
+    readonly layout: EventLayout;
+    readonly date: PlainDate;
+    readonly href: string | null;
+    readonly color: string | null;
+    readonly status: string | null;
+    readonly allDay: boolean;
+    readonly bar: boolean;
+    readonly open: boolean;
+    readonly continuesBefore: boolean;
+    readonly continuesAfter: boolean;
+    readonly clippedStart: boolean;
+    readonly clippedEnd: boolean;
+    readonly short: boolean;
+    /** It ended before now: drawn a step back. */
+    readonly past: boolean;
+    /** Moves and resizes: `editable` said so and it is drawn in the grid, not a list. */
+    readonly editable: boolean;
+    readonly dragging: boolean;
+    /** Being dragged over a destination `canDrop` refuses. */
+    readonly dropInvalid: boolean;
+    readonly context: boolean;
+    /** The end an edit can pull, only where the event ends in this drawing. */
+    readonly resizable: boolean;
+    readonly time: string | null;
+    readonly title: string;
+    readonly location: string | null;
+    readonly meta: string;
+    readonly style: Record<string, number>;
+}
+interface MonthCell {
+    readonly iso: string;
+    readonly date: PlainDate;
+    readonly label: string;
+    readonly count: string;
+    readonly tabIndex: number;
+    readonly today: boolean;
+    readonly outside: boolean;
+    readonly nonWorking: boolean;
+    readonly selected: boolean;
+    readonly events: readonly EventView[];
+    readonly continuations: readonly string[];
+    readonly more: number;
+    readonly moreLabel: string;
+}
+interface MonthRow {
+    readonly key: string;
+    readonly weekNumber: number;
+    readonly cells: readonly MonthCell[];
+}
+interface MonthDrawing {
+    readonly weekdays: readonly {
+        key: string;
+        short: string;
+        long: string;
+    }[];
+    readonly rows: readonly MonthRow[];
+}
+interface ColumnHeader {
+    readonly iso: string;
+    readonly date: PlainDate;
+    readonly weekday: string;
+    readonly label: string;
+    readonly tabIndex: number;
+    readonly today: boolean;
+    readonly offsetShort: string | null;
+    readonly offsetLong: string | null;
+}
+interface AllDayCell {
+    readonly iso: string;
+    readonly date: PlainDate;
+    readonly tabIndex: number;
+    readonly today: boolean;
+    readonly nonWorking: boolean;
+    readonly selected: boolean;
+    readonly events: readonly EventView[];
+    readonly continuations: readonly string[];
+}
+interface ColumnMoreView {
+    readonly count: number;
+    /** One column: a count laid over the events it hides, not a column. */
+    readonly overlay: boolean;
+    readonly label: string;
+    readonly style: Record<string, number>;
+}
+interface ColumnView {
+    readonly iso: string;
+    readonly date: PlainDate;
+    readonly tabIndex: number;
+    readonly today: boolean;
+    readonly nonWorking: boolean;
+    readonly offHours: readonly Record<string, number>[];
+    readonly offsetLine: Record<string, number> | null;
+    readonly selection: {
+        style: Record<string, number>;
+        text: string;
+    } | null;
+    readonly items: readonly EventView[];
+    readonly more: readonly ColumnMoreView[];
+    readonly now: Record<string, number> | null;
+}
+interface TimeGridDrawing {
+    readonly days: number;
+    readonly zone: string;
+    readonly lanes: number;
+    readonly hours: readonly {
+        hour: number;
+        label: string;
+    }[];
+    readonly headers: readonly ColumnHeader[];
+    readonly allDay: readonly AllDayCell[];
+    readonly columns: readonly ColumnView[];
+}
+interface ListDayView {
+    readonly iso: string;
+    readonly headingId: string;
+    readonly heading: {
+        readonly weekday: string;
+        readonly date: string;
+        readonly label: string;
+    };
+    readonly today: boolean;
+    readonly events: readonly EventView[];
+}
+
+/**
+ * The content of every event, in all four places it is drawn. The family keeps
+ * the element — a link or a button — its name, its focus and its geometry;
+ * the template writes what is inside it.
+ */
+declare class SlEventCalendarEvent {
+    readonly template: TemplateRef<EventCalendarEventContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarEvent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarEvent, "ng-template[slEventCalendarEvent]", never, {}, {}, never, never, true, never>;
+}
+/** Given, the family opens its own popover with this content, anchored to the event. */
+declare class SlEventCalendarDetail {
+    readonly template: TemplateRef<EventCalendarDetailContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarDetail, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarDetail, "ng-template[slEventCalendarDetail]", never, {}, {}, never, never, true, never>;
+}
+/** The consumer's content for a day: a price, a count of free slots, a holiday. */
+/**
+ * The items of the menu a secondary click, a long press or `Shift+F10` opens on
+ * the grid — `slMenuItem`, `sl-menu-separator`, a nested menu — for the
+ * target. `slEventCalendarContextMenuFor` narrows the targets that have a
+ * menu; the others keep the browser's own.
+ */
+declare class SlEventCalendarContextMenu {
+    readonly template: TemplateRef<EventCalendarContextMenuContext>;
+    readonly for: _angular_core.InputSignal<(target: EventCalendarContextTarget) => boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarContextMenu, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarContextMenu, "ng-template[slEventCalendarContextMenu]", never, { "for": { "alias": "slEventCalendarContextMenuFor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SlEventCalendarDayContent {
+    readonly template: TemplateRef<EventCalendarDayContentContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarDayContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarDayContent, "ng-template[slEventCalendarDayContent]", never, {}, {}, never, never, true, never>;
+}
+/** The consumer's controls, at the end of the header. */
+declare class SlEventCalendarActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarActions, "[slEventCalendarActions]", never, {}, {}, never, never, true, never>;
+}
+/** The action under the list's empty sentence — the one that creates an event. */
+declare class SlEventCalendarEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarEmpty, "[slEventCalendarEmpty]", never, {}, {}, never, never, true, never>;
+}
+/** A message and a retry, above the grid. The grid stays usable. */
+declare class SlEventCalendarError {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendarError, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlEventCalendarError, "[slEventCalendarError]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A calendar of events: month, week, day and list, over wall-clock values.
+ *
+ * **The events are the consumer's.** The family expands their recurrence, lays
+ * them out and asks, with a reason, to move the date, the view, the calendars
+ * in view, the chosen stretch of time and the open event. Each is a `model()`
+ * with a `…Request` output carrying the `ChangeRequest`, which the consumer can
+ * cancel before anything commits.
+ *
+ * **The grid is a layout grid from the APG with the day as its cell.** One cell
+ * holds the tab stop; arrows move the day; Enter goes into the day's events and
+ * Escape comes back out. The list is not a grid: every event is in the tab
+ * order, under a heading per day.
+ *
+ * **Below the compact size class the month and the week are a list** of the
+ * same days, without the view changing.
+ *
+ * It is not a form control: nothing it holds is a submitted value, so it
+ * implements no `ControlValueAccessor`.
+ */
+declare class SlEventCalendar implements OnInit {
+    readonly events: _angular_core.InputSignal<readonly CalendarEvent[]>;
+    readonly calendars: _angular_core.InputSignal<readonly EventCalendarCalendar[]>;
+    /** The views the switcher offers, in order. */
+    readonly views: _angular_core.InputSignal<readonly EventCalendarView[]>;
+    /** The day the calendar is on. Two-way. */
+    readonly date: _angular_core.ModelSignal<PlainDate | undefined>;
+    readonly defaultDate: _angular_core.InputSignal<PlainDate | undefined>;
+    readonly view: _angular_core.ModelSignal<EventCalendarView | undefined>;
+    readonly defaultView: _angular_core.InputSignal<EventCalendarView | undefined>;
+    /** Keys of the calendars drawn. Unbound starts with all of them. */
+    readonly visibleCalendars: _angular_core.ModelSignal<readonly string[] | undefined>;
+    readonly defaultVisibleCalendars: _angular_core.InputSignal<readonly string[] | undefined>;
+    readonly selectionMode: _angular_core.InputSignal<EventCalendarSelectionMode>;
+    readonly selection: _angular_core.ModelSignal<EventCalendarSelection | null | undefined>;
+    readonly defaultSelection: _angular_core.InputSignal<EventCalendarSelection | null | undefined>;
+    /** The key of the occurrence whose detail is open. */
+    readonly openEvent: _angular_core.ModelSignal<string | null | undefined>;
+    readonly defaultOpenEvent: _angular_core.InputSignal<string | null | undefined>;
+    /** Keeps an occurrence when it returns true — a search, a `filter-bar` predicate. */
+    readonly filter: _angular_core.InputSignal<((occurrence: EventOccurrence) => boolean) | undefined>;
+    /** Events move and resize, by dragging or by Alt and the arrows; a predicate decides per occurrence. */
+    readonly editable: _angular_core.InputSignalWithTransform<boolean | ((occurrence: EventOccurrence) => boolean), unknown>;
+    readonly workingHours: _angular_core.InputSignal<readonly WorkingHours[]>;
+    readonly header: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly level: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly compact: _angular_core.InputSignal<EventCalendarCompact | undefined>;
+    readonly dayHours: _angular_core.InputSignal<readonly [number, number] | undefined>;
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly fixedWeeks: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly hourCycle: _angular_core.InputSignal<EventCalendarHourCycle | undefined>;
+    readonly listRange: _angular_core.InputSignal<EventCalendarListRange | undefined>;
+    readonly loadingDelay: _angular_core.InputSignal<number | undefined>;
+    readonly loadingMinDuration: _angular_core.InputSignal<number | undefined>;
+    /** BCP 47. Unset, the language in force (`provideSlotted`) decides. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * toolbar, the views, the empty and loading states, the counts and the
+     * sentences said aloud.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<EventCalendarMessages> | undefined>;
+    readonly maxColumns: _angular_core.InputSignal<number | undefined>;
+    readonly maxEvents: _angular_core.InputSignal<number | undefined>;
+    readonly scrollTime: _angular_core.InputSignal<PlainTime | undefined>;
+    /** Minutes, 5 to 120: the lighter rules and the step of a selection or a drag. */
+    readonly slotDuration: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly weekends: _angular_core.InputSignal<EventCalendarWeekends | undefined>;
+    readonly weekNumbers: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly dateRequest: _angular_core.OutputEmitterRef<ChangeRequest<PlainDate>>;
+    readonly viewRequest: _angular_core.OutputEmitterRef<ChangeRequest<EventCalendarView>>;
+    readonly visibleCalendarsRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    readonly selectionRequest: _angular_core.OutputEmitterRef<ChangeRequest<EventCalendarSelection | null>>;
+    readonly openEventRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | null>>;
+    /**
+     * Before an event moves or its end does. Not a model: the family holds no
+     * event, and the application answers by changing `events`.
+     */
+    readonly eventChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<EventCalendarEventChange>>;
+    /**
+     * Whether an event may land where it is being moved, asked with the change
+     * `eventChangeRequest` would carry: at every step of a drag, and at every
+     * step Alt and an arrow try. A refused destination is drawn as refused, and
+     * letting go there puts the event back and asks for nothing.
+     */
+    readonly canDrop: _angular_core.InputSignal<((change: EventCalendarEventChange) => boolean) | undefined>;
+    /** A fact, after the period in view changes: fetch it. */
+    readonly rangeChange: _angular_core.OutputEmitterRef<EventCalendarRange>;
+    protected readonly eventContentTemplate: _angular_core.Signal<SlEventCalendarEvent | undefined>;
+    protected readonly detail: _angular_core.Signal<SlEventCalendarDetail | undefined>;
+    protected readonly dayContent: _angular_core.Signal<SlEventCalendarDayContent | undefined>;
+    protected readonly actions: _angular_core.Signal<SlEventCalendarActions | undefined>;
+    protected readonly empty: _angular_core.Signal<SlEventCalendarEmpty | undefined>;
+    protected readonly errorContent: _angular_core.Signal<SlEventCalendarError | undefined>;
+    private readonly body;
+    private readonly scroller;
+    private readonly filterButton;
+    private readonly morePopover;
+    private readonly detailPopover;
+    private readonly defaults;
+    protected readonly host: HTMLElement;
+    private readonly injector;
+    private readonly writtenLabel;
+    protected readonly id: string;
+    protected readonly titleId: string;
+    private readonly appLocale;
+    /** The family's words in the language in force, with this calendar's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<EventCalendarMessages>;
+    private readonly localeValue;
+    private readonly zoneValue;
+    private readonly cycleValue;
+    private readonly hoursValue;
+    protected readonly slotDurationValue: _angular_core.Signal<number>;
+    private readonly scrollValue;
+    protected readonly maxEventsValue: _angular_core.Signal<number>;
+    private readonly maxColumnsValue;
+    /**
+     * As many columns as blocks of 64 pixels — a word of a wrapped title and its
+     * padding — fit in a day's column, never more than `maxColumns`; with one,
+     * the first column's events are drawn whole and the rest is a count laid
+     * over them. The event's container query has already hidden the time at
+     * this width.
+     */
+    private readonly columnsThatFit;
+    protected readonly weekNumbersValue: _angular_core.Signal<boolean>;
+    protected readonly loadingDelayValue: _angular_core.Signal<number>;
+    protected readonly loadingMinDurationValue: _angular_core.Signal<number>;
+    private readonly viewOptions;
+    private readonly firstDate;
+    protected readonly currentDate: _angular_core.Signal<PlainDate>;
+    /** Which view is showing. Public, so a template reaches it through `exportAs`. */
+    readonly currentView: _angular_core.Signal<EventCalendarView>;
+    protected readonly shown: _angular_core.Signal<readonly string[]>;
+    private readonly currentSelection;
+    protected readonly currentOpen: _angular_core.Signal<string | null>;
+    private readonly now;
+    private readonly today;
+    protected readonly narrow: _angular_core.WritableSignal<boolean>;
+    private readonly row;
+    private readonly pending;
+    protected readonly moreDate: _angular_core.WritableSignal<PlainDate | null>;
+    protected readonly moreIso: _angular_core.Signal<string | null>;
+    protected readonly detailAnchor: _angular_core.WritableSignal<HTMLElement | null>;
+    /** The "+N" or the day number a day's sheet returns focus to. */
+    protected readonly moreAnchor: _angular_core.WritableSignal<HTMLElement | null>;
+    protected readonly layout: _angular_core.Signal<"list" | "grid">;
+    protected readonly range: _angular_core.Signal<_slotted_core_event_calendar.VisibleRange>;
+    private readonly collator;
+    private readonly occurrences;
+    private readonly canEdit;
+    /**
+     * The occurrence a pointer is moving, drawn where it would land: the views
+     * lay the proposal out like any other placement, so a moved block takes its
+     * columns and pushes its neighbours as it will once the application agrees.
+     */
+    private readonly editing;
+    private readonly laidOut;
+    protected readonly title: _angular_core.Signal<string>;
+    private readonly drawingInput;
+    protected readonly monthDrawing: _angular_core.Signal<MonthDrawing>;
+    protected readonly timeDrawing: _angular_core.Signal<TimeGridDrawing>;
+    protected readonly listDrawing: _angular_core.Signal<readonly ListDayView[]>;
+    protected readonly moreViews: _angular_core.Signal<readonly EventView[]>;
+    protected readonly openOccurrence: _angular_core.Signal<EventOccurrence<CalendarEvent> | null>;
+    protected readonly hostsDetail: _angular_core.Signal<boolean>;
+    protected readonly emptyKey: _angular_core.Signal<"month" | "week" | "day">;
+    /** The empty state's sentence for the period in view. */
+    protected readonly emptyText: _angular_core.Signal<string>;
+    /** The names of the two steps, which say how far each one moves. */
+    protected readonly previousLabel: _angular_core.Signal<string>;
+    protected readonly nextLabel: _angular_core.Signal<string>;
+    /** A view's name in the switcher. */
+    protected viewLabel(view: EventCalendarView): string;
+    /**
+     * The indicator exists while there is a wait, and a little after: through
+     * the delay it may still be withheld in, and the hold it keeps once shown.
+     * Mounted with nothing to report it was an element that is only `hidden`,
+     * and a `hidden` progress bar is still painted in its linear shape.
+     */
+    protected readonly loaderMounted: _angular_core.WritableSignal<boolean>;
+    /** One day's column, measured: a cluster never draws blocks too narrow for a word. */
+    private readonly columnWidth;
+    private selectionAnchor;
+    private drag;
+    private edit;
+    /** A drag ends in a click on the event it moved; that click opens nothing. */
+    private swallowClick;
+    protected readonly closeDetail: () => boolean;
+    protected readonly contextMenu: _angular_core.Signal<SlEventCalendarContextMenu | undefined>;
+    private readonly contextMenuRef;
+    protected readonly contextInjector: _angular_core.Signal<_angular_core.DestroyableInjector | null>;
+    /**
+     * The target of the menu that shows, and the element it stands on. Its event
+     * carries `data-context`; its stretch is drawn as the selection being made,
+     * so the reader sees what "New event" will cover before choosing it.
+     */
+    protected readonly contextOn: _angular_core.WritableSignal<{
+        target: EventCalendarContextTarget;
+        element: HTMLElement;
+    } | null>;
+    private aimed;
+    private readonly contextKey;
+    private readonly contextSlot;
+    protected readonly contextLabel: _angular_core.Signal<string | undefined>;
+    constructor();
+    ngOnInit(): void;
+    requestDate(next: PlainDate, reason: ChangeReason, source?: unknown): boolean;
+    requestView(next: EventCalendarView, reason: ChangeReason, source?: unknown): boolean;
+    private requestVisible;
+    requestSelection(next: EventCalendarSelection | null, reason: ChangeReason, source?: unknown): boolean;
+    requestOpen(next: string | null, reason: ChangeReason, source?: unknown): boolean;
+    /** The change the family would ask for: `canDrop` and `eventChangeRequest` read the same one. */
+    private changeFor;
+    private allows;
+    /** Asks the application to put an occurrence somewhere else; the family holds no event. */
+    requestEventChange(occurrence: EventOccurrence, placement: EventPlacement, kind: 'move' | 'resize', reason: ChangeReason, source?: unknown): boolean;
+    /** Puts focus on the cell holding the grid's tab stop, or the first event of a list. */
+    focus(): void;
+    /** Moves the calendar to a date and focuses its cell. */
+    focusDate(next: PlainDate): void;
+    /** Focuses an occurrence that is drawn, by key; returns whether one was. */
+    focusEvent(key: string): boolean;
+    /** Scrolls the hours so `time` is at the top. */
+    scrollToTime(time: PlainTime): void;
+    protected swatch(key: string): string;
+    /** When the open occurrence happens, as the two parts the detail writes. */
+    protected whenOf(occurrence: EventOccurrence): {
+        readonly day: string | null;
+        readonly range: string;
+    };
+    protected dateLabel(date: PlainDate): string;
+    protected step(direction: 1 | -1, event: MouseEvent): void;
+    protected goToday(event: MouseEvent): void;
+    protected onViewRequest(request: ChangeRequest<string | undefined>): void;
+    protected onCalendarRequest(key: string, request: ChangeRequest<boolean>): void;
+    protected drill(date: PlainDate, event: MouseEvent): void;
+    protected activate(view: EventView, event: MouseEvent): void;
+    protected openMore(date: PlainDate, event: MouseEvent): void;
+    protected onMoreOpen(open: boolean): void;
+    protected onDetailRequest(request: ChangeRequest<boolean>): void;
+    private eventElement;
+    private focusCell;
+    /** A stretch in words: the day, its hours, or the first and the last day. */
+    private stretchWords;
+    private announce;
+    private minuteAt;
+    /**
+     * The press is aimed before the `context-menu` family sees it — at an event,
+     * or at the stretch under the pointer. A press at nothing, or at a target
+     * the application gives no menu, is stopped here, so the family never
+     * prevents it and the browser's own menu opens.
+     */
+    private aimAt;
+    private readonly onContextCapture;
+    private readonly onContextKeyCapture;
+    private readonly onPressCapture;
+    protected onContextRequest(request: ChangeRequest<boolean>): void;
+    private readonly onClickCapture;
+    /**
+     * A press on an editable event picks it up once it travels four pixels;
+     * short of that it is a click. The resize handle moves the end only.
+     */
+    private startEdit;
+    protected onPointerDown(event: PointerEvent): void;
+    /** Alt and an arrow move the event a slot or a day; with Shift, its end. */
+    private editByKey;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlEventCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlEventCalendar, "[slEventCalendar]", ["slEventCalendar"], { "events": { "alias": "events"; "required": false; "isSignal": true; }; "calendars": { "alias": "calendars"; "required": false; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "defaultDate": { "alias": "defaultDate"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "defaultView": { "alias": "defaultView"; "required": false; "isSignal": true; }; "visibleCalendars": { "alias": "visibleCalendars"; "required": false; "isSignal": true; }; "defaultVisibleCalendars": { "alias": "defaultVisibleCalendars"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "defaultSelection": { "alias": "defaultSelection"; "required": false; "isSignal": true; }; "openEvent": { "alias": "openEvent"; "required": false; "isSignal": true; }; "defaultOpenEvent": { "alias": "defaultOpenEvent"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "workingHours": { "alias": "workingHours"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "dayHours": { "alias": "dayHours"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "fixedWeeks": { "alias": "fixedWeeks"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "listRange": { "alias": "listRange"; "required": false; "isSignal": true; }; "loadingDelay": { "alias": "loadingDelay"; "required": false; "isSignal": true; }; "loadingMinDuration": { "alias": "loadingMinDuration"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "maxColumns": { "alias": "maxColumns"; "required": false; "isSignal": true; }; "maxEvents": { "alias": "maxEvents"; "required": false; "isSignal": true; }; "scrollTime": { "alias": "scrollTime"; "required": false; "isSignal": true; }; "slotDuration": { "alias": "slotDuration"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "weekends": { "alias": "weekends"; "required": false; "isSignal": true; }; "weekNumbers": { "alias": "weekNumbers"; "required": false; "isSignal": true; }; "canDrop": { "alias": "canDrop"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "view": "viewChange"; "visibleCalendars": "visibleCalendarsChange"; "selection": "selectionChange"; "openEvent": "openEventChange"; "dateRequest": "dateRequest"; "viewRequest": "viewRequest"; "visibleCalendarsRequest": "visibleCalendarsRequest"; "selectionRequest": "selectionRequest"; "openEventRequest": "openEventRequest"; "eventChangeRequest": "eventChangeRequest"; "rangeChange": "rangeChange"; }, ["eventContentTemplate", "detail", "dayContent", "actions", "empty", "errorContent", "contextMenu"], ["[slEventCalendarActions]", "[slEventCalendarError]", "[slEventCalendarEmpty]"], true, never>;
+}
+
+export { EVENT_CALENDAR_DEFAULTS, EVENT_CALENDAR_FALLBACK, SlEventCalendar, SlEventCalendarActions, SlEventCalendarContextMenu, SlEventCalendarDayContent, SlEventCalendarDetail, SlEventCalendarEmpty, SlEventCalendarError, SlEventCalendarEvent, injectEventCalendarDefaults, provideEventCalendarDefaults };
+export type { EventCalendarCompact, EventCalendarContextMenuContext, EventCalendarContextTarget, EventCalendarDayContentContext, EventCalendarDefaults, EventCalendarDetailContext, EventCalendarEventChange, EventCalendarEventContext, EventCalendarHourCycle, EventCalendarRange, EventCalendarSelection, EventCalendarSelectionMode };
+//# sourceMappingURL=slotted-angular-event-calendar.d.ts.map

package/types/slotted-angular-event-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-event-calendar.d.ts","sources":["../../event-calendar/src/event-calendar-defaults.ts","../../event-calendar/src/event-calendar-view.ts","../../event-calendar/src/event-calendar-templates.ts","../../event-calendar/src/event-calendar.ts"],"mappings":"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","names":["__event_calendar_view.MonthDrawing","__event_calendar_view.TimeGridDrawing","__event_calendar_view.ListDayView"]}