@mintplayer/ng-bootstrap 21.29.0 → 21.31.0

package/types/mintplayer-ng-bootstrap-web-components-scheduler.d.ts

@@ -25,10 +25,13 @@ declare class MpScheduler extends LitElement {
     private previousView;
     private previousDate;
     private previousSelectedEventId;
+    private previousRangeKey;
     private pendingDragUpdate;
     private latestDragState;
     private boundHandleKeyDown;
+    private boundHandleFocusIn;
     private nowIndicatorTimer;
+    private readonly liveAnnouncer;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -54,6 +57,13 @@ declare class MpScheduler extends LitElement {
     today(): void;
     gotoDate(date: Date): void;
     changeView(view: ViewType): void;
+    /**
+     * Clear the time-range selection and the focused-cell selection. Public
+     * because — per PRD scheduler-controlled-selection — the WC no longer
+     * auto-clears on commit; consumers call this from their `event-create`
+     * handler if they want the post-create selection cleared.
+     */
+    clearSelection(): void;
     addEvent(event: SchedulerEvent): void;
     updateEvent(event: SchedulerEvent): void;
     removeEvent(eventId: string): void;
@@ -74,7 +84,156 @@ declare class MpScheduler extends LitElement {
     private handleDragComplete;
     private handleClick;
     private handleDoubleClick;
+    /**
+     * When focus lands on an event block (Tab, programmatic, or click), select
+     * the event and emit `event-selected` for mouse-parity (PRD §6.5 D3). The
+     * subsequent setSelectedEvent call routes through detectAndEmitChanges
+     * which fires `selection-change`.
+     *
+     * `focusin` bubbles across shadow boundaries but `e.target` is retargeted
+     * to the host. Use composedPath()[0] for the actual focused element.
+     */
+    private handleFocusIn;
     private handleKeyDown;
+    private getFocusedKind;
+    private handleAltShortcut;
+    private handleEventKeyDown;
+    /**
+     * Inter-event arrow nav (PRD scheduler-controlled-selection §5.3): walk
+     * the events in document order (start time, with id as tiebreaker) by ±1.
+     * No wrap at the ends — matches the APG list/feed pattern.
+     */
+    private focusAdjacentEvent;
+    private handleCellKeyDown;
+    /**
+     * If a cell is the active element but state.focusedCell is empty (e.g.
+     * Tab landed on the fallback first cell), seed the state from the
+     * active element's data attributes.
+     */
+    private initFocusedCellFromActive;
+    /**
+     * Month-view keyboard handler (PRD scheduler-controlled-selection §5.1).
+     * Arrows walk days; ArrowUp/Down ± one week; cross-month moves auto-
+     * advance the displayed date so the new month renders. Enter emits
+     * `event-create` for the focused day's full range.
+     */
+    private handleMonthCellKeyDown;
+    /**
+     * Year-view keyboard handler (PRD scheduler-controlled-selection §5.2).
+     * The focus unit is a month — ArrowLeft/Right ± 1, ArrowUp/Down ± 3 to
+     * mirror the visual 4×3 layout. Cross-year auto-advances. Enter emits
+     * `event-create` for the focused month's full range.
+     */
+    private handleYearCellKeyDown;
+    /**
+     * Sync `focusedDate` from the currently-active month/year cell. Runs at
+     * the top of every Phase B keydown so click-driven and Tab-driven focus
+     * moves are reflected in state before arrow keys read it.
+     */
+    private syncFocusedDateFromActive;
+    private moveFocusedDateByDays;
+    private moveFocusedDateByMonths;
+    /**
+     * Apply a focused-date update. If the new date crosses the displayed
+     * period (different month on month view; different year on year view),
+     * also bump `state.date` so the view re-renders to the new period —
+     * APG date-picker auto-advance behaviour. Then schedule a focus
+     * restoration on the matching cell after the next render.
+     */
+    private commitFocusedDate;
+    /**
+     * Find the month/year date-cell DOM element by id and focus it. Keys are
+     * built from *local* date components to match `MonthView.dayKey()` /
+     * `YearView.monthKey()` — see those helpers for why ISO is unsafe across
+     * non-UTC timezones.
+     */
+    private scrollAndFocusDateCell;
+    /**
+     * Emit `event-create` covering the focused day (month view) or focused
+     * month (year view). No internal mutation per PRD
+     * scheduler-controlled-selection — consumer constructs the actual event.
+     */
+    private commitFocusedDateAsCreate;
+    private moveCellByTime;
+    /** Week view ArrowLeft/Right: ±1 day, same time-of-day. No-op on day view. */
+    private moveCellByDay;
+    /** Timeline ArrowUp/Down: ±1 resource, same time-of-day. PRD D1: cross-resource
+     *  Shift+Arrow is intentionally ignored (resource is categorical). */
+    private moveCellByResource;
+    private moveCellToColumnExtreme;
+    private moveCellToViewExtreme;
+    /**
+     * PageUp/PageDown — advance one period (week or day) and re-focus the same
+     * day-of-week + time-of-day in the new period. Selection is cleared since
+     * crossing a period boundary breaks the linear-range invariant.
+     */
+    private moveCellByPeriod;
+    /**
+     * Apply the focus move to state and DOM. `extend` grows the selection
+     * range; otherwise selection is cleared. Live-region announces the new
+     * focused cell or selection range.
+     */
+    private commitFocusMove;
+    private cellIsWithinView;
+    private parseTimeOnDay;
+    private adjacentResource;
+    private getResourceTitle;
+    /**
+     * Find the cell DOM element for a (slot, resource) pair and call .focus()
+     * on it. scrollIntoView with block:nearest provides parity with mouse
+     * drag-near-edge auto-pan (PRD D6).
+     */
+    private scrollAndFocusCell;
+    /** Re-focus whatever cell the keyboard model currently considers focused. */
+    private focusFocusedCell;
+    private cssEscape;
+    /**
+     * Emit `event-create` covering the active selection range, or a single
+     * cell when no selection is active. Per PRD scheduler-controlled-selection,
+     * this is a *request* — no internal state mutation, no auto-clear, no
+     * auto-focus. The consumer constructs the SchedulerEvent and decides
+     * whether/when to clear the selection.
+     */
+    private createEventFromCellOrSelection;
+    /**
+     * Active keyboard-driven event move. Captures the original time range and
+     * (timeline) resource so Escape can revert; the working copy is mutated in
+     * place by arrow keys and committed or rolled back on Enter / Escape.
+     */
+    private keyboardMove;
+    /**
+     * Enter keyboard event-move mode. Captures the working copy and a snapshot
+     * of the resource (timeline). Visual feedback is provided by routing the
+     * working start/end through the existing previewEvent state — the same
+     * channel used for mouse drag — so the event renders at the projected
+     * destination as the user nudges.
+     */
+    private enterEventMoveMode;
+    /**
+     * Move-mode keymap. Layered on the existing M-mode foundation:
+     *   - bare Arrow keys nudge the event
+     *   - Shift+Arrow resizes the end edge
+     *   - Alt+Shift+Arrow resizes the start edge
+     *   - on week view, Shift+ArrowLeft/Right pushes the end edge across the
+     *     day boundary (PRD D5) — symmetric with Shift+ArrowDown for time.
+     *   - Enter commits, Escape reverts.
+     */
+    private handleKeyboardMove;
+    private minutesPerSlot;
+    /** Shift the working event by `deltaMs` along the time axis (preserves duration). */
+    private nudgeKeyboardMove;
+    /** Walk to the next/previous resource (timeline only). Updates the preview's resourceId. */
+    private nudgeKeyboardMoveResource;
+    /**
+     * Resize one edge of the working event. Clamps to a minimum duration of
+     * one slot to keep the event valid, and refuses to invert (start ≤ end).
+     */
+    private resizeKeyboardMoveEdge;
+    /** Mirror keyboardMove.working* into state.previewEvent so views render the destination,
+     *  then scroll the destination into view so the sighted-keyboard user can see it (PRD D6). */
+    private applyKeyboardMovePreview;
+    private commitEventMoveMode;
+    private cancelEventMoveMode;
     private startNowIndicatorTimer;
     private stopNowIndicatorTimer;
     private getSlotAtPosition;
@@ -111,6 +270,26 @@ interface SchedulerState {
     isMouseDown: boolean;
     /** Loading state */
     isLoading: boolean;
+    /** Currently keyboard-focused cell. Drives roving tabindex inside the grid. */
+    focusedCell: TimeSlot | null;
+    /** Resource pinned to the focused cell (timeline view only). */
+    focusedResourceId: string | null;
+    /** The cell where the user first held Shift to begin a range selection. */
+    selectionAnchor: TimeSlot | null;
+    /** Current end-cell of the keyboard-driven selection. Range spans from the
+     *  earliest cell.start to the latest cell.end across both anchor and extent. */
+    selectionExtent: TimeSlot | null;
+    /** Resource pinned at the anchor (timeline only); cross-resource selection is intentionally ignored (PRD D1). */
+    selectionResourceId: string | null;
+    /** ID of the event currently in keyboard move-mode (PRD §6.6). Drives `aria-pressed` on the event button. */
+    keyboardMoveEventId: string | null;
+    /**
+     * Keyboard-focused day on month-view, or first-of-month on year-view.
+     * Distinct from `focusedCell` (which carries a slot range), because month-
+     * and year-view cells aren't time slots — month cells are whole days, year
+     * cells are whole months.
+     */
+    focusedDate: Date | null;
 }
 /**
  * Create initial scheduler state
@@ -227,6 +406,27 @@ declare class SchedulerStateManager {
      * Navigate to a specific date
      */
     gotoDate(date: Date): void;
+    /**
+     * Move the keyboard focus to a cell. Setting `clearSelection` (default)
+     * also drops any active range selection — used for plain Arrow nav, where
+     * Shift would have stayed held to keep the range alive.
+     */
+    setFocusedCell(cell: TimeSlot | null, resourceId?: string | null, clearSelection?: boolean): void;
+    /**
+     * Begin or extend a range selection. Anchor is set on first call (when
+     * Shift is first held), pinned at the *previously-focused* cell. Extent
+     * moves with each subsequent Shift+Arrow.
+     */
+    extendSelection(extent: TimeSlot, resourceId?: string | null): void;
+    /**
+     * Clear any active range selection without touching the focused cell.
+     */
+    clearSelection(): void;
+    /**
+     * Move the keyboard focus to a calendar date — used by month and year views
+     * (PRD scheduler-controlled-selection §5). Pass `null` to clear.
+     */
+    setFocusedDate(date: Date | null): void;
 }
 
 /**
@@ -275,8 +475,22 @@ declare abstract class BaseView {
  * Year view renderer
  */
 declare class YearView extends BaseView {
+    /** Cache of `.scheduler-year-month` cards keyed by `YYYY-MM`. */
+    private monthCards;
     render(): void;
+    /**
+     * Build a `YYYY-MM` key from a Date, which is the unit of focus on year
+     * view (PRD scheduler-controlled-selection §5.2 — year cells are months,
+     * not days).
+     */
+    private static monthKey;
     private createMonthCard;
+    /**
+     * Apply roving tabindex based on `state.focusedDate`'s month. Year-view's
+     * focus unit is a month, so we strip down `focusedDate` to its `YYYY-MM`
+     * key. Falls back to the displayed year's first month if no focus yet.
+     */
+    private updateMonthCardFocus;
     update(state: SchedulerState): void;
     destroy(): void;
 }
@@ -287,7 +501,20 @@ declare class YearView extends BaseView {
 declare class MonthView extends BaseView {
     private dayCells;
     render(): void;
+    /**
+     * Build a `YYYY-MM-DD` key from a Date using *local* components. Using
+     * `toISOString()` here would shift the key in any non-UTC timezone (a
+     * local midnight on May 12 in CEST is May 11 22:00 UTC), and the resulting
+     * cell IDs would not match the visible day numbers.
+     */
+    static dayKey(d: Date): string;
     private createDayCell;
+    /**
+     * Apply roving tabindex based on `state.focusedDate`. The grid must always
+     * have exactly one tab-reachable cell, so when no date is focused yet we
+     * fall back to today (if visible) or the first day of the displayed month.
+     */
+    private updateDayCellFocus;
     private renderEvents;
     update(state: SchedulerState): void;
     private optionsRequireRerender;
@@ -303,6 +530,14 @@ declare class WeekView extends BaseView {
     private slotElements;
     render(): void;
     update(state: SchedulerState): void;
+    /**
+     * Apply roving tabindex and aria-selected to each cached slot element. Also
+     * toggles the `.selected` class so the existing `.scheduler-time-slot.selected`
+     * styling lights up cells in the keyboard-driven range. A linear time-range
+     * selection (PRD D1) lights up every slot whose [start, end) intersects
+     * the range, including across day boundaries on week view.
+     */
+    private updateCellFocusAndSelection;
     private optionsRequireRerender;
     private renderEvents;
     private createEventElement;
@@ -321,6 +556,11 @@ declare class DayView extends BaseView {
     private slotElements;
     private dayColumn;
     render(): void;
+    /**
+     * Apply roving tabindex + aria-selected + `.selected` class to each cached
+     * slot element based on focusedCell and selection range.
+     */
+    private updateCellFocusAndSelection;
     private renderEvents;
     private createEventElement;
     private renderNowIndicator;
@@ -339,6 +579,12 @@ declare class TimelineView extends BaseView {
     private rowElements;
     private slotWidth;
     render(): void;
+    /**
+     * Apply roving tabindex + aria-selected + `.selected` class to each
+     * timeline-slot element. Selection is constrained to the resource pinned
+     * at the anchor (PRD D1: cross-resource selection ignored).
+     */
+    private updateCellFocusAndSelection;
     private createResourceRow;
     private renderEvents;
     private createEventElement;

package/types/mintplayer-ng-bootstrap-web-components-splitter.d.ts

@@ -28,10 +28,76 @@ interface PanelInfo {
     initialSize?: number;
 }
 
+interface NormalizedPointerEvent {
+    clientX: number;
+    clientY: number;
+    point: Point;
+    originalEvent: MouseEvent | TouchEvent;
+    isTouch: boolean;
+}
+declare function normalizePointerEvent(event: MouseEvent | TouchEvent): NormalizedPointerEvent;
+
+interface InputHandlerCallbacks {
+    onResizeStart: (event: NormalizedPointerEvent, dividerIndex: number, dividerElement: HTMLElement) => void;
+    onResizeMove: (event: NormalizedPointerEvent) => void;
+    onResizeEnd: (event: NormalizedPointerEvent) => void;
+    /**
+     * Keyboard-driven resize. Fires once per arrow / Home / End keystroke on a
+     * focused divider. Granularity is encoded as the boolean `fine` (Shift held)
+     * — translation to percent/px lives in the splitter, not the input layer.
+     */
+    onResizeKey?: (key: ResizeKey, fine: boolean, dividerIndex: number, dividerElement: HTMLElement) => void;
+}
+type ResizeKey = 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'Home' | 'End';
+declare class InputHandler {
+    private isActive;
+    private currentDividerIndex;
+    private currentDividerElement;
+    private callbacks;
+    private boundMouseMove;
+    private boundMouseUp;
+    private boundTouchMove;
+    private boundTouchEnd;
+    constructor(callbacks: InputHandlerCallbacks);
+    attachDividerListeners(divider: HTMLElement, index: number): void;
+    private handleKeyDown;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private startResize;
+    private endResize;
+    dispose(): void;
+    getIsActive(): boolean;
+}
+
 interface SplitterResizeEventDetail {
     sizes: number[];
     orientation: Direction;
 }
+/**
+ * `<mp-splitter>` — resizable panel splitter.
+ *
+ * Light-DOM children are projected into named slots (`panel-${i}`) inside a
+ * shadow-DOM flex container with auto-inserted dividers between them. Drag a
+ * divider to redistribute space; sizes survive container resize via a
+ * proportional rescale.
+ *
+ * Pointer + keyboard interactions both flow through the same path:
+ * - Pointer drag → `InputHandler` → `handleResizeStart/Move/End`.
+ * - Arrow keys ±10% (Shift = ±1%), Home/End to limits → `handleResizeKey`.
+ *
+ * ARIA: each divider is a `role="separator"` with `aria-orientation`,
+ * `aria-controls` referencing the deterministic IDs of the two adjacent
+ * panel wrappers, and percent-based `aria-valuenow / valuemin / valuemax`
+ * that update on every drag-preview frame, container resize, and keystroke.
+ *
+ * Public API: `[orientation]`, `[min-panel-size]`, `[touch-mode]`;
+ * `getPanelSizes()` / `setPanelSizes()`; events `resize-start`, `resizing`,
+ * `resize-end` carrying `{ sizes, orientation }`.
+ */
 declare class MpSplitter extends LitElement {
     static styles: lit.CSSResult[];
     static get observedAttributes(): string[];
@@ -45,6 +111,7 @@ declare class MpSplitter extends LitElement {
     private mutationObserver;
     private containerResizeObserver;
     private unsubscribeState;
+    private readonly instanceId;
     constructor();
     render(): TemplateResult;
     protected firstUpdated(): void;
@@ -57,9 +124,30 @@ declare class MpSplitter extends LitElement {
     get touchMode(): boolean;
     set touchMode(value: boolean);
     getPanelSizes(): number[];
+    /**
+     * Drive a keyboard-style resize on a divider programmatically. Used by the
+     * dock manager's intersection-handle keymap so a single keystroke can
+     * resize both the horizontal and vertical dividers a 2D handle sits on,
+     * without re-implementing the percent-step + clamp math here.
+     *
+     * `key` is one of the keys handled by the divider keymap
+     * (Arrow{Left,Right,Up,Down}, Home, End); `fine` halves the step (matches
+     * Shift modifier on the keyboard path).
+     */
+    resizeDividerBy(dividerIndex: number, key: ResizeKey, fine?: boolean): void;
     setPanelSizes(sizes: number[]): void;
     private setupMutationObserver;
     private subscribeToState;
+    /**
+     * Mirror current panel sizes to each divider's aria-valuenow / valuemin /
+     * valuemax as percent of container. Per §10 Q3 of the WC ARIA PRD: percent
+     * is more intuitive for SR users than pixels.
+     *
+     * Per-divider math: divider i sits between panels[i] and panels[i+1] and
+     * "owns" the size of panels[i]. valuemin = minPanelSize as % of container;
+     * valuemax = (panels[i].size + panels[i+1].size - minPanelSize) as %.
+     */
+    private updateDividerAriaValues;
     private updatePanelsFromSlot;
     /**
      * Read each panel-wrapper's measured pixel size and persist it as the
@@ -82,6 +170,13 @@ declare class MpSplitter extends LitElement {
     private handleResizeStart;
     private handleResizeMove;
     private handleResizeEnd;
+    /**
+     * Keyboard-driven resize on a focused divider. ArrowKeys ±10% (Shift = ±1%)
+     * along the splitter's axis; Home/End shrink/grow panelBefore to its limit.
+     * Fires resize-start → resize-end with the new sizes so consumers don't
+     * need to special-case keyboard vs. drag.
+     */
+    private handleResizeKey;
     private applyPanelSizes;
 }
 
@@ -122,43 +217,6 @@ declare class ResizeManager {
     getMinPanelSize(): number;
 }
 
-interface NormalizedPointerEvent {
-    clientX: number;
-    clientY: number;
-    point: Point;
-    originalEvent: MouseEvent | TouchEvent;
-    isTouch: boolean;
-}
-declare function normalizePointerEvent(event: MouseEvent | TouchEvent): NormalizedPointerEvent;
-
-interface InputHandlerCallbacks {
-    onResizeStart: (event: NormalizedPointerEvent, dividerIndex: number, dividerElement: HTMLElement) => void;
-    onResizeMove: (event: NormalizedPointerEvent) => void;
-    onResizeEnd: (event: NormalizedPointerEvent) => void;
-}
-declare class InputHandler {
-    private isActive;
-    private currentDividerIndex;
-    private currentDividerElement;
-    private callbacks;
-    private boundMouseMove;
-    private boundMouseUp;
-    private boundTouchMove;
-    private boundTouchEnd;
-    constructor(callbacks: InputHandlerCallbacks);
-    attachDividerListeners(divider: HTMLElement, index: number): void;
-    private handleMouseDown;
-    private handleMouseMove;
-    private handleMouseUp;
-    private handleTouchStart;
-    private handleTouchMove;
-    private handleTouchEnd;
-    private startResize;
-    private endResize;
-    dispose(): void;
-    getIsActive(): boolean;
-}
-
 declare const splitterStyles: lit.CSSResult;
 
 export { InputHandler, MpSplitter, ResizeManager, ResizeState, SplitterStateManager, normalizePointerEvent, splitterStyles };