@prolibu-suite/cobalt-core 0.7.0 → 0.9.0

package/dist/types/components/co-button/co-button.d.ts

@@ -10,12 +10,29 @@ export declare class CoButton {
     size: 'l' | 'm' | 's' | 'xs';
     /** Raised elevation — with variant="secondary" renders a white raised button (shadow-sm + inset hairline). */
     elevated: boolean;
-    /** Surface the button sits on. On "dark", ghost/stroke variants switch to white ink + blanco-16 hover. */
+    /**
+     * Surface the button sits on. On "dark", ghost/stroke variants switch to
+     * white ink + blanco-16 hover; danger keeps its solid error fill but swaps
+     * the fade-hover for a lighten-hover + white focus ring (dark bars dim a
+     * faded red). Receta oficial de acciones de barra (co-action-bar):
+     * `variant="ghost"|"stroke" surface="dark"`; Eliminar =
+     * `variant="danger" surface="dark"`.
+     */
     surface: 'light' | 'dark';
     /** Disabled state */
     disabled: boolean;
     /** Text label (alternative to default slot) */
     label?: string;
+    /**
+     * Accessible name override for icon-only buttons (no visible `label`/slot
+     * text, e.g. an icon-only action inside `co-action-bar`) — the shadow
+     * `<button>` otherwise has no accessible name. Mirrors the exact
+     * `ariaLabelText` precedent of `co-fab`/`co-icon-button`. Only sets
+     * `aria-label` when THIS prop is passed — when a visible `label`/slot IS
+     * present, its text content already gives the button an accessible name,
+     * so leaving `ariaLabelText` unset avoids a duplicate/overriding aria-label.
+     */
+    ariaLabelText?: string;
     /** Phosphor icon name for the left position (e.g. "plus", "arrow-left") */
     iconLeft?: string;
     /** Phosphor icon name for the right position (e.g. "arrow-right", "download") */

package/dist/types/components/co-calendar-month/co-calendar-month.d.ts

@@ -36,19 +36,26 @@ export declare class CoCalendarMonth {
     selectable: boolean;
     /** Max event lanes per day before "+N more". */
     maxLanes: number;
+    /** Cargando: en vez de los chips pinta bloques skeleton en sus carriles. La
+     *  grilla del mes (cabecera de días, celdas, números, bordes) no se toca. */
+    loading: boolean;
     /** Day holding roving focus. */
     focused: string;
     /** Day currently hovered while dragging an event. */
     dragOverDate: string | null;
     /** Id of the event being dragged. */
     dragId: string | null;
+    /** Epoch ms of "now", refreshed on a 60s timer so `past` styling stays live. */
+    nowMs: number;
     /** Emitted when an empty day is selected (create request). Detail = "YYYY-MM-DD". */
     coDaySelect: EventEmitter<{
         date: string;
+        rect?: DOMRect;
     }>;
     /** Emitted when an event chip is activated. */
     coEventClick: EventEmitter<{
         id: string;
+        rect?: DOMRect;
     }>;
     /** Emitted on a completed drag-move (day granularity). */
     coEventDrop: EventEmitter<{
@@ -63,21 +70,46 @@ export declare class CoCalendarMonth {
     coMoreClick: EventEmitter<{
         date: string;
     }>;
+    /** Doble activación de un chip (direct-edit request del host). */
+    coEventDblClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
     private onPointerUp;
+    private nowTimer?;
+    /** Root ref para el classList imperativo del FIX D (sin @State: no debe
+     * disparar un render por celda cruzada durante el drag). */
+    private rootEl?;
+    /** Memo de layoutMonth/matrix/segByWeek/byId por identidad de inputs. Durante
+     * el drag-over de celdas (pointerenter → dragOverDate @State) ninguno de estos
+     * inputs cambia → hit puro, sin recomputar layoutMonth/getMonthMatrix/segByWeek. */
+    private _layoutCache?;
     componentWillLoad(): void;
+    componentDidLoad(): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
     private defaultFocus;
-    private get matrix();
     private eventById;
     private isDayInteractable;
+    /** Día seleccionado que PERSISTE resaltado mientras el host tiene abierto su
+     * form/bubble de creación (referencia visual, paridad Google). */
+    selectedDate: string | null;
     private selectDay;
+    /** Limpia el resaltado persistente (lo llama el host al cerrar su form). */
+    clearSelection(): Promise<void>;
+    /** Un refetch (post-save) invalida la referencia visual. */
+    onEventsChange(): void;
     private activateEvent;
     private moveFocus;
     private focusCell;
     private handleKeyDown;
+    /** Marca la interacción en el root (pointer-events:none en los chips durante el
+     * drag — mata el hover/hit-testing de las barras all-day barridas en cada
+     * celda cruzada). No es @State a propósito: no debe disparar un render. */
+    private setInteracting;
     private startDrag;
     private finishDrag;
+    private getLayouts;
     private renderChip;
     render(): any;
 }

package/dist/types/components/co-calendar-timegrid/co-calendar-timegrid.d.ts

@@ -0,0 +1,178 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * co-calendar-timegrid — the Week/Day time-grid. The shell renders it with
+ * `dates` = 7 day-keys (week) or 1 (day). Presentation + interaction only; the
+ * host owns data (CONTROLLED). All instant math is delegated to the engine — the
+ * only timezone boundary is the `timeZone` prop (wall-clock render).
+ */
+export declare class CoCalendarTimegrid {
+    el: HTMLElement;
+    events: NormalizedEvent[];
+    /** Visible day keys "YYYY-MM-DD" (7 = week, 1 = day). */
+    dates: string[];
+    locale: string;
+    timeZone: string;
+    editable: boolean;
+    selectable: boolean;
+    minDate?: string;
+    maxDate?: string;
+    slotMinutes: number;
+    snapMinutes: number;
+    defaultDurationMinutes: number;
+    scrollTime: string;
+    nowIndicator: boolean;
+    /** Cargando: en vez de los eventos pinta bloques skeleton en las columnas.
+     *  La grilla (eje de horas, líneas, cabecera de días, franja de todo-el-día)
+     *  se mantiene: lo único que todavía no se sabe son los eventos. */
+    loading: boolean;
+    allDaySlot: boolean;
+    minTime: string;
+    maxTime: string;
+    /** Minute of "now" for the indicator; refreshed on a 60s timer. */
+    nowMinutes: number;
+    nowDay: string;
+    /** Roving-tabindex focus position for keyboard navigation over slots. */
+    focusDate: string;
+    focusMin: number;
+    /** A time range was selected on an empty area (create request). */
+    coRangeSelect: EventEmitter<{
+        start: string;
+        end: string;
+        /** Viewport-anchored rect of the selected area, for the host to anchor a quick-create bubble. */
+        rect?: {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    coEventClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
+    coEventDrop: EventEmitter<{
+        id: string;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+    }>;
+    /** Doble activación de un chip (direct-edit request del host). */
+    coEventDblClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
+    selDate: string | null;
+    selStartMin: number;
+    selEndMin: number;
+    private selecting;
+    /** Coords crudas del último pointermove: el getBoundingClientRect corre UNA vez
+     * por frame, dentro del rAF (antes corría a ~120Hz, en el move crudo). */
+    private pendingSel;
+    private selRaf;
+    private pendingDrag;
+    private dragRaf;
+    private onWindowPointerUp;
+    dragId: string | null;
+    private dragMode;
+    private dragGrabOffsetMin;
+    private dragDurationMin;
+    private dragDate;
+    private dragStartMin;
+    private dragEndMin;
+    private origStartMin;
+    private origEndMin;
+    private origDate;
+    private suppressNextClick;
+    private dragArmedId;
+    private dragStartPointer;
+    private onWindowPointerMove;
+    private onWindowPointerUpDrag;
+    private nowTimer?;
+    private rootEl?;
+    private scrollEl?;
+    /** Ghost imperativo del drag: se posiciona con style directo, nunca por vdom. */
+    private ghostEl?;
+    /** Rects de las columnas cacheados AL AGARRAR: con esto el frame de drag es
+     * aritmética pura (antes: ~9 getBoundingClientRect + 2 querySelector/frame,
+     * que además forzaban reflow síncrono al escribir estilos en el mismo rAF). */
+    private colRects;
+    private gridRect;
+    private onDragViewportChange;
+    /** Memo de layoutTimeGrid/layoutAllDay/byId por identidad de inputs. */
+    private layoutCache?;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    /** Limpia el resaltado persistente de selección (lo llama el host al cerrar
+     * su bubble/form de creación). */
+    clearSelection(): Promise<void>;
+    /** Un refetch (post-save) invalida la referencia visual de la selección. */
+    onEventsChange(): void;
+    private refreshNow;
+    private get minM();
+    private get maxM();
+    private scrollToInitial;
+    /** Visible day keys, with the same fallback the render uses. */
+    private visibleDates;
+    /** Slot size guarded: ahora alimenta un `calc()` (un 0/NaN dejaría la grilla
+     * sin altura, silenciosamente). */
+    private get slotM();
+    /** Number of slot rows in the visible window (drives the body height). */
+    private slotCount;
+    /** Hour marks inside the visible window — one axis label each (was 1 div per
+     * slot with a label only on the hour). */
+    private hourList;
+    /** Minutes-of-day at a clientY within a column element, snapped and clamped. */
+    private minutesFromPointer;
+    /** Same math as minutesFromPointer but over the cached grid rect (drag path):
+     * cero lecturas de layout por frame. */
+    private minutesFromCachedY;
+    private minutesAtFraction;
+    /** Snapshot de la geometría de columnas al empezar un drag. Se re-toma solo
+     * cuando el viewport cambia (scroll del body / resize), nunca por frame. */
+    private captureDragRects;
+    private bindDragViewportListeners;
+    /** Marca la interacción en el root (hover/hit-testing off en los chips). No es
+     * @State a propósito: no debe disparar un render por drag. */
+    private setInteracting;
+    /** Build an ISO instant (UTC) for a wall-clock minute-of-day on a given day. */
+    private toInstant;
+    private isDayInteractable;
+    private startSelection;
+    private extendSelection;
+    private finishSelection;
+    /** Viewport rect of the selected span, mirroring the `.tg__selection` ghost's
+     * fraction math over the column's own bounding box. Never throws: falls back to
+     * the whole-column rect, or undefined if the column isn't in the DOM. */
+    private selectionRect;
+    private eventById;
+    /** The day column under a clientX (week can drop across days) — resuelto por
+     * aritmética sobre los rects cacheados, sin tocar el DOM. */
+    private dateKeyAtX;
+    private startMove;
+    private startResize;
+    private beginDragInteraction;
+    /** Ghost del drag escrito DIRECTO al DOM: el vdom no participa (los campos del
+     * drag son privados a propósito — promoverlos a @State volvería a re-renderizar
+     * la grilla entera por frame). */
+    private paintGhost;
+    private hideGhost;
+    /** Igual que extendSelection: un solo apply por frame (ver comentario allí). */
+    private trackDrag;
+    private applyDrag;
+    private finishDrag;
+    /** Roving-tabindex keyboard nav: ↑/↓ by slot, ←/→ by day, Enter/Space to select. */
+    private handleKeyDown;
+    private shiftFocusDate;
+    private renderSelectionGhost;
+    private renderEventBox;
+    private renderAllDayBar;
+    /** Los 3 cómputos de layout del render, memoizados por IDENTIDAD de inputs
+     * (`events` llega memoizado del shell): un re-render por drag/now-tick/focus
+     * no vuelve a empaquetar la semana. */
+    private getLayouts;
+    render(): any;
+}

package/dist/types/components/co-combobox/co-combobox.d.ts

@@ -59,7 +59,7 @@ export declare class CoCombobox {
     /** Emitted when the selection changes. `item` is the picked option (the
      *  option-list's native `{ _id, label }` shape); `null` on clear. */
     coChange: EventEmitter<{
-        value: string[] | string;
+        value: string[] | string | null;
         item: {
             _id: string;
             label: string;

package/dist/types/components/co-command-search/co-command-search.d.ts

@@ -76,6 +76,13 @@ export declare class CoCommandSearch {
     /** Two-stage commit: keepOpen items emit coScopeChange only; all others emit coSelect + close. */
     private selectItem;
     private close;
+    /**
+     * Escape a nivel PANEL: el `handleKeyDown` del input solo dispara con el input
+     * enfocado, así que al hacer click en una tab/chip/"Más" o mover el foco a la
+     * lista de resultados el Escape se perdía (el palette quedaba atrapado hasta
+     * completar una acción). El keydown burbujea desde cualquier hijo hasta acá.
+     */
+    private handlePanelKeyDown;
     private handleOverlayClick;
     private handlePanelClick;
     private handleTriggerClick;

package/dist/types/components/co-date-time-picker/co-date-time-picker.d.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { Placement } from '../../utils/positioning';
+/**
+ * Date + TIME picker: one field, one popover. Composes `co-popover` (floating
+ * panel, outside-click) + `co-calendar` (day grid) + a scrollable list of times
+ * beside it — the Google Calendar layout.
+ *
+ * VALUE CONTRACT — the committed `value` is a UTC ISO instant
+ * ("2026-07-25T21:30:00.000Z"), never a wall-clock string. The wall clock the
+ * user sees and edits is rendered in `timeZone` (IANA; browser zone when
+ * omitted). All ISO↔wall-clock conversion goes through the calendar engine
+ * (`@prolibu-suite/cobalt-calendar-utils`), so DST comes from the platform tz
+ * database — the same boundary `co-calendar-timegrid` uses. A date-only value
+ * ("2026-07-25") is NOT an instant: it is read as that wall-clock day in
+ * `timeZone` at {@link DEFAULT_MINUTES} (09:00), never as UTC midnight (which
+ * would shift the day west of UTC).
+ *
+ * INTERACTION (Google):
+ *   - Click the field → opens. Picking a DAY commits and keeps the panel open
+ *     (you almost always want to set the hour next); picking a TIME commits and
+ *     closes. So there is no draft/apply step and no confirm button.
+ *   - ArrowDown on the field → moves focus into the calendar grid.
+ *   - The time list is a listbox: Arrow/Home/End/PageUp/PageDown move the active
+ *     option, Enter/Space selects it.
+ *   - Escape → closes and returns focus to the field. Outside click → closes.
+ *
+ * Escape is owned here (co-popover `closeOnEscape=false`) so focus can return to
+ * the field; outside-click stays with co-popover.
+ *
+ * @part field - The bordered trigger row
+ * @part label - The field label
+ * @part display - The button that shows the formatted value
+ * @part clear - The clear button
+ * @part helper - The helper/error text row
+ */
+export declare class CoDateTimePicker {
+    el: HTMLElement;
+    /** Committed value: UTC ISO instant ("2026-07-25T21:30:00.000Z") or null. */
+    value: string | null;
+    /** IANA zone the wall clock is rendered in. Defaults to the browser zone. */
+    timeZone?: string;
+    /** Minutes between consecutive options in the time list. */
+    stepMinutes: number;
+    /** 12-hour clock (Google style). `false` renders a 24h clock. */
+    hour12: boolean;
+    /** Earliest selectable day. Date-only "YYYY-MM-DD" or an instant. */
+    min?: string;
+    /** Latest selectable day. Date-only "YYYY-MM-DD" or an instant. */
+    max?: string;
+    disabledDates?: string[] | string;
+    disabledDaysOfWeek?: number[] | string;
+    locale: string;
+    /** Date part of the trigger text (tokens yyyy/yy/MMMM/MMM/MM/M/dd/d). */
+    displayFormat: string;
+    firstDayOfWeek: number;
+    label?: string;
+    placeholder?: string;
+    /** Field size, mirrors co-input/co-date-field: s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
+    /** `flat` strips the trigger's border/background so it reads as content. */
+    variant: 'default' | 'flat';
+    name?: string;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    clearable: boolean;
+    invalid: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside). */
+    layout: 'vertical' | 'horizontal';
+    /** Popover placement relative to the field. */
+    placement: Placement;
+    /** Whether the panel is open. */
+    open: boolean;
+    /** Max viewport width (px) that renders the panel as a bottom sheet. */
+    mobileBreakpoint: number;
+    /** True when the viewport is at/under `mobileBreakpoint`. */
+    isMobile: boolean;
+    /** Minutes-of-day highlighted by the keyboard in the time list. */
+    activeMinutes: number;
+    /** Committed instant (UTC ISO) or null. */
+    coChange: EventEmitter<string | null>;
+    coClear: EventEmitter<void>;
+    coFocus: EventEmitter<void>;
+    coBlur: EventEmitter<void>;
+    coOpen: EventEmitter<void>;
+    coClose: EventEmitter<void>;
+    private popoverEl?;
+    private calendarEl?;
+    private triggerBtn?;
+    private listEl?;
+    private pendingFocusGrid;
+    private pendingFocusTrigger;
+    /** 'center' when the list is (re)opened, 'nearest' while arrowing through it. */
+    private pendingScroll;
+    private mql?;
+    private mqlHandler;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    onOpenChange(next: boolean): void;
+    private get zone();
+    private get isInvalid();
+    /** Wall clock of the committed value in `zone`, or null when empty/invalid. */
+    private get parts();
+    /** Calendar bounds are date-only; accept an instant and reduce it to its day. */
+    private dayBound;
+    private setOpen;
+    /** Write day+minutes as a UTC instant and notify. */
+    private commit;
+    private onTriggerKeyDown;
+    private onClearClick;
+    private onCalendarSelect;
+    private pickTime;
+    private onListKeyDown;
+    private onPopoverOpen;
+    private onPopoverClose;
+    private onRootKeyDown;
+    private focusGridSoon;
+    private scrollActiveIntoView;
+    componentDidRender(): void;
+    private get step();
+    /** Grid of minutes-of-day, plus the committed hour when it falls off-grid
+     *  (an imported 16:37 meeting must stay visible and selectable). */
+    private get options();
+    private renderTrigger;
+    private renderPanel;
+    private renderHelper;
+    private renderLabel;
+    render(): any;
+}

package/dist/types/components/co-event-calendar/co-event-calendar.d.ts

@@ -4,8 +4,8 @@ import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobal
  * co-event-calendar — the public entry point of the Cobalt Calendars family.
  *
  * Owns view state, the visible anchor date, event normalization and the toolbar,
- * and delegates rendering to the active view (Phase 1: month). All hard math
- * lives in `@prolibu-suite/cobalt-calendar-utils`. Events are CONTROLLED: the
+ * and delegates rendering to the active view (month/week/day; agenda pending).
+ * All hard math lives in `@prolibu-suite/cobalt-calendar-utils`. Events are CONTROLLED: the
  * calendar emits requests (`coEventDrop`, `coDateSelect`) and the host applies
  * them by updating the `events` prop — leaving it unchanged on failure is the
  * revert.
@@ -16,8 +16,16 @@ import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobal
  * @part toolbar - The header toolbar
  * @part body - The active view container
  */
+type StatusColorsProp = Record<string, {
+    backgroundColor?: string;
+    borderColor?: string;
+}> | string;
 export declare class CoEventCalendar {
-    /** Active view. Phase 1 ships `month`; week/day/agenda land in later phases. */
+    el: HTMLElement;
+    /** Limpia el resaltado persistente de selección de la vista activa (timegrid
+     * o month) — lo llama el host al cerrar su bubble/form de creación. */
+    clearRangeSelection(): Promise<void>;
+    /** Active view. `month`/`week`/`day` are implemented; `agenda` is pending. */
     view: 'month' | 'week' | 'day' | 'agenda';
     /** Anchor date "YYYY-MM-DD" controlling the visible period. Persisted by host. */
     date?: string;
@@ -42,23 +50,45 @@ export declare class CoEventCalendar {
     /** Views offered in the switcher. Defaults to the implemented set. */
     availableViews: string[] | string;
     /** Optional status→{backgroundColor,borderColor} map (object or JSON string). */
-    statusColors?: Record<string, {
-        backgroundColor?: string;
-        borderColor?: string;
-    }> | string;
+    statusColors?: StatusColorsProp;
     /** Default minutes for a timed event missing an end. */
     defaultDurationMinutes: number;
+    /** Show the all-day lane in week/day views. */
+    allDaySlot: boolean;
+    /** Visible-hours window for week/day (minutes-of-day bounds as "HH:mm"). */
+    minTime: string;
+    maxTime: string;
+    /** Slot/snap granularity (minutes) for week/day. */
+    slotMinutes: number;
+    snapMinutes: number;
+    /** Initial scroll position for week/day ("HH:mm"). */
+    scrollTime: string;
+    /** Show the current-time indicator in week/day. */
+    nowIndicator: boolean;
+    /** Cargando eventos: se propaga a la grilla (mes/timegrid), que reemplaza
+     *  SUS chips por bloques skeleton y conserva toda su estructura — bordes,
+     *  cabecera de días, eje de horas. El toolbar sigue operable y nada se
+     *  desmonta, así no se pierde el scroll de semana/día. */
+    loading: boolean;
     /** Internal anchor (YYYY-MM-DD) — mirrors `date`, defaults to today. */
     anchor: string;
     /** An event chip was activated. */
     coEventClick: EventEmitter<{
         event: NormalizedEvent;
+        rect: DOMRect | null;
     }>;
     /** A date/range was selected (create request). */
     coDateSelect: EventEmitter<{
         start: string;
         end: string;
         allDay: boolean;
+        /** Viewport-anchored rect of the selected day/range, for the host to anchor a quick-create bubble. */
+        rect: DOMRect | {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        } | null;
     }>;
     /** An event was dragged to a new time (move). `revert` is a host convenience. */
     coEventDrop: EventEmitter<{
@@ -70,6 +100,11 @@ export declare class CoEventCalendar {
         allDay: boolean;
         revert: () => void;
     }>;
+    /** An event chip was double-activated (direct-edit request). */
+    coEventDblClick: EventEmitter<{
+        event: NormalizedEvent;
+        rect: DOMRect | null;
+    }>;
     /** The visible period changed → host should refetch and persist the view pref. */
     coDatesSet: EventEmitter<{
         view: string;
@@ -90,9 +125,24 @@ export declare class CoEventCalendar {
     componentDidLoad(): void;
     onDateChange(value?: string): void;
     private get tz();
+    /**
+     * Memo for the `normalized` getter below. Re-normalizing on every access is
+     * wasted work (render reads it twice) AND, since `normalizeEvents` always
+     * returns a fresh array, breaks referential-equality memos downstream that
+     * depend on a stable `events` reference (layout/packing caching). Keyed by
+     * the raw prop identities that feed normalization — `events`/`statusColors`
+     * are compared by `===` (stable array/string/object reference from the
+     * host unless it actually changed), `defaultDurationMinutes` by value.
+     */
+    private _normCache?;
     private get normalized();
     private get viewsList();
-    /** Visible [start, end) of the current month view, as date strings. */
+    /** Sunday=0 UTC day-of-week of a date-only key (tz-independent). */
+    private dowOf;
+    private weekStart;
+    /** Day keys the active view renders: 7 for week, 1 for day, [] for month. */
+    private get visibleDates();
+    /** Visible [start, end) of the active view, as date strings. */
     private visibleRange;
     private emitDatesSet;
     private setAnchor;
@@ -102,9 +152,12 @@ export declare class CoEventCalendar {
     private step;
     private switchView;
     private handleDaySelect;
+    private handleRangeSelect;
     private handleEventClick;
+    private handleEventDblClick;
     private handleEventDrop;
     private handleMoreClick;
     private title;
     render(): any;
 }
+export {};

package/dist/types/components/co-event-popover/co-event-popover.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type Placement } from '../../utils/positioning';
+/**
+ * co-event-popover — anchored detail card (Google-Calendar-style) for a calendar
+ * event. Non-modal, dismissible. Anchors to a viewport `anchorRect` (the chip's
+ * getBoundingClientRect), promotes to the top-layer (the calendar shell has
+ * contain:layout ancestors that re-anchor position:fixed), and closes on Escape /
+ * outside-click. Content is slotted by the host (suite-v2 fills the meeting fields).
+ */
+export declare class CoEventPopover {
+    el: HTMLElement;
+    open: boolean;
+    /** Anchor rect in viewport coords (chip.getBoundingClientRect()). */
+    anchorRect?: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    placement: Placement;
+    /** Accent color for the leading dot (event color). */
+    color?: string;
+    /** Render the leading color dot. Set false for dot-less content (quick-create). */
+    dot: boolean;
+    closeOnEscape: boolean;
+    closeOnClickOutside: boolean;
+    /** Accessible name for the panel (role="dialog" needs one). */
+    popoverLabel?: string;
+    coClose: EventEmitter<void>;
+    private panelEl?;
+    private prevFocus?;
+    componentDidLoad(): void;
+    onOpenChange(v: boolean): void;
+    onAnchorChange(): void;
+    disconnectedCallback(): void;
+    private promoteAndPosition;
+    private dismissPanel;
+    private teardownListeners;
+    private position;
+    private onScroll;
+    private onKeydown;
+    private onPointerDown;
+    private requestClose;
+    render(): any;
+}

package/dist/types/components/co-menu-item/co-menu-item.d.ts

@@ -21,6 +21,9 @@ export declare class CoMenuItem {
     iconSize?: number;
     /** Text shown in the row. */
     label?: string;
+    /** Optional second line under the label (muted, smaller) — e.g. what an
+     *  export method means. The row auto-grows (min-height, not height). */
+    caption?: string;
     /** Tighter row metrics (32px instead of 36px). */
     dense: boolean;
     /** Marks the row as selected — paints an at-rest gray-100 background. Used by