@prolibu-suite/cobalt-core 0.2.0 → 0.3.0

package/dist/esm/tz-B6JZk8fL.js

@@ -0,0 +1,119 @@
+/**
+ * tz.ts — IANA timezone conversion for the Cobalt calendar engine.
+ *
+ * The calendar STORES instants as UTC ISO-8601 ("…Z") and RENDERS wall-clock
+ * time in a target IANA zone. Browsers expose exactly one tz-correct primitive:
+ * `Intl.DateTimeFormat` with a `timeZone` option. Everything here is built on
+ * it, with ZERO dependencies, so DST is resolved by the platform's tz database
+ * (kept current by the OS) rather than a bundled rule set.
+ *
+ * Vocabulary:
+ *   - an "instant" is a point in time: epoch milliseconds, a Date, or an ISO
+ *     string WITH an offset/Z designator (date-time strings parse unambiguously;
+ *     bare "YYYY-MM-DD" is NOT an instant — see {@link model.ts} all-day events).
+ *   - a "wall clock" is the calendar-and-clock reading a person standing in
+ *     `timeZone` would see at that instant.
+ *
+ * Why not `new Date(str)` everywhere: that is only safe for date-TIME strings
+ * carrying an offset (which is all this module accepts). Bare date-only strings
+ * parse as UTC midnight and shift the day in negative-offset zones — that hazard
+ * is owned by `@prolibu-suite/cobalt-date-utils`, never here.
+ */
+const pad2 = (n) => String(n).padStart(2, '0');
+const FMT_CACHE = new Map();
+/** Cached parts formatter for a zone (constructing Intl.DateTimeFormat is costly). */
+function partsFormatter(timeZone) {
+    let f = FMT_CACHE.get(timeZone);
+    if (!f) {
+        f = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        FMT_CACHE.set(timeZone, f);
+    }
+    return f;
+}
+/** Normalize any {@link Instant} to epoch milliseconds. */
+function toEpoch(instant) {
+    if (typeof instant === 'number')
+        return instant;
+    if (instant instanceof Date)
+        return instant.getTime();
+    const t = Date.parse(instant);
+    if (Number.isNaN(t))
+        throw new RangeError(`tz: invalid instant "${instant}"`);
+    return t;
+}
+/** The browser's current IANA timezone (e.g. "America/Bogota"). */
+function getLocalTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+/** The wall-clock reading at `instant`, observed in `timeZone`. */
+function getWallClock(instant, timeZone) {
+    const parts = partsFormatter(timeZone).formatToParts(new Date(toEpoch(instant)));
+    const read = (type) => {
+        const p = parts.find((x) => x.type === type);
+        return p ? Number(p.value) : 0;
+    };
+    let hour = read('hour');
+    // Defensive: some engines emit "24" for midnight under hour-cycle edge cases.
+    if (hour === 24)
+        hour = 0;
+    return {
+        year: read('year'),
+        month: read('month'),
+        day: read('day'),
+        hour,
+        minute: read('minute'),
+        second: read('second'),
+    };
+}
+/**
+ * Minutes EAST of UTC at `instant`, observed in `timeZone`.
+ * America/Bogota → -300 (UTC-5); America/New_York in summer → -240 (UTC-4).
+ */
+function getOffsetMinutes(instant, timeZone) {
+    const epoch = toEpoch(instant);
+    const wc = getWallClock(epoch, timeZone);
+    const asUTC = Date.UTC(wc.year, wc.month - 1, wc.day, wc.hour, wc.minute, wc.second);
+    return Math.round((asUTC - epoch) / 60000);
+}
+/**
+ * Convert a wall-clock reading INTERPRETED in `timeZone` to a UTC instant.
+ *
+ * Handles DST: the offset is sampled at a first guess, applied, then re-sampled
+ * because the offset that applies depends on the very instant we're computing.
+ * A single correction step resolves every regular DST transition. In a
+ * spring-forward gap (a wall time that never existed) this yields the consistent
+ * post-transition instant; in a fall-back overlap it yields the first (earlier)
+ * occurrence — both are deterministic, documented conventions.
+ */
+function wallClockToEpoch(wc, timeZone) {
+    const guess = Date.UTC(wc.year, wc.month - 1, wc.day, wc.hour ?? 0, wc.minute ?? 0, wc.second ?? 0);
+    const off1 = getOffsetMinutes(guess, timeZone);
+    const utc1 = guess - off1 * 60000;
+    const off2 = getOffsetMinutes(utc1, timeZone);
+    return off2 === off1 ? utc1 : guess - off2 * 60000;
+}
+/** Canonical UTC "…Z" string for any instant. */
+function toUtcISO(instant) {
+    return new Date(toEpoch(instant)).toISOString();
+}
+/** Wall-clock date key "YYYY-MM-DD" at `instant` in `timeZone` (for day bucketing). */
+function zonedDateKey(instant, timeZone) {
+    const wc = getWallClock(instant, timeZone);
+    return `${wc.year}-${pad2(wc.month)}-${pad2(wc.day)}`;
+}
+/** Minutes since local midnight at `instant` in `timeZone` (for time-grid layout). */
+function zonedMinutesOfDay(instant, timeZone) {
+    const wc = getWallClock(instant, timeZone);
+    return wc.hour * 60 + wc.minute;
+}
+
+export { toUtcISO as a, zonedMinutesOfDay as b, getWallClock as c, getLocalTimeZone as g, toEpoch as t, wallClockToEpoch as w, zonedDateKey as z };

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

@@ -17,6 +17,8 @@ export declare class CoAutocomplete {
     helperText?: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input): s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
     /** Pre-loaded or server-returned options */
     options: AutocompleteOption[] | string[] | string;

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

@@ -15,6 +15,8 @@ export declare class CoAvatar {
     shape: 'circle' | 'square';
     /** Custom background color (hex or CSS value) */
     color?: string;
+    /** Optional 2px ring color (hex/CSS). Drives the inset ::after ring. */
+    ringColor?: string;
     imgFailed: boolean;
     private handleImgError;
     render(): any;

package/dist/types/components/co-avatar-group/co-avatar-group.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/** One avatar descriptor consumed by `co-avatar-group`. Mirrors `co-avatar`'s props. */
+export interface CoAvatarGroupItem {
+    type?: 'text' | 'icon' | 'image';
+    text?: string;
+    src?: string;
+    icon?: string;
+    color?: string;
+    shape?: 'circle' | 'square';
+    /** Full name — used to compose the group's accessible label. */
+    name?: string;
+    /** Optional ring color forwarded to the child `co-avatar`. */
+    ringColor?: string;
+}
+export declare class CoAvatarGroup {
+    /** Avatar descriptors rendered as an overlapping stack. */
+    items: CoAvatarGroupItem[];
+    /** Max avatars shown before the remainder collapses into a "+N" badge. `0` = show all. */
+    max: number;
+    /** Size forwarded to every avatar (and the overflow badge). */
+    size: 'xl' | 'lg' | 'md' | 'sm' | 'xs' | 'xxs';
+    /** Shape forwarded to every avatar that doesn't set its own. */
+    shape: 'circle' | 'square';
+    /** Make the whole group a focusable button (role=button, keyboard, coClick). */
+    interactive: boolean;
+    /** Accessible label override; when absent it's composed from the items' names. */
+    label?: string;
+    /** Emitted on click / Enter / Space when `interactive`. Does NOT bubble. */
+    coClick: EventEmitter<void>;
+    private activate;
+    private accessibleLabel;
+    render(): any;
+}

package/dist/types/components/co-bottom-sheet/co-bottom-sheet.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Mobile bottom sheet with native drag physics: the sheet follows the finger
+ * 1:1 downward, a fast flick (or a slow release past ~45% of its height)
+ * dismisses it, upward overdrag rubber-bands, and the backdrop opacity is
+ * coupled to the drag. The body scrolls internally — dragging from the body
+ * only engages when its content is scrolled to the top.
+ *
+ * Height fits the content, capped by `maxHeight` (default 85dvh).
+ *
+ * @slot header - Custom header content (overrides `heading`). Dragging it moves the sheet.
+ * @slot        - Sheet body (scrollable).
+ * @slot footer - Pinned action area below the body (outside the scroll), with safe-area padding.
+ */
+export declare class CoBottomSheet {
+    el: HTMLElement;
+    /** Whether the sheet is visible */
+    open: boolean;
+    /** Sheet title (used when the `header` slot is empty) */
+    heading: string;
+    /** Maximum sheet height (any CSS length; content shorter than this hugs) */
+    maxHeight: string;
+    /** Allow closing with the drag gesture. When false, drags rubber-band back. */
+    dismissible: boolean;
+    /** Close when tapping the backdrop */
+    closeOnOverlay: boolean;
+    /** Close when pressing Escape */
+    closeOnEscape: boolean;
+    /** Show the grab handle */
+    showHandle: boolean;
+    /** Requested to close (gesture, backdrop, Esc). Consumer should set `open=false`. */
+    coClose: EventEmitter<void>;
+    /** Transitioned to open=true. */
+    coOpen: EventEmitter<void>;
+    /** Slide-in animation finished. */
+    coAfterOpen: EventEmitter<void>;
+    /** Slide-out animation finished. */
+    coAfterClose: EventEmitter<void>;
+    hasFooter: boolean;
+    hasHeaderSlot: boolean;
+    private sheetEl?;
+    private backdropEl?;
+    private bodyEl?;
+    private tracker;
+    private armed;
+    private engaged;
+    private fromBody;
+    private startY;
+    private startX;
+    private startScrollTop;
+    private sheetHeight;
+    private dismissPending;
+    private dismissFallback?;
+    private pendingAfter;
+    onOpenChange(next: boolean, prev: boolean): void;
+    handleKey(e: KeyboardEvent): void;
+    disconnectedCallback(): void;
+    private clearInlineStyles;
+    private handleBackdropClick;
+    private slotHasContent;
+    private handleFooterSlotChange;
+    private handleHeaderSlotChange;
+    private handleTransitionEnd;
+    private handleGripPointerDown;
+    private handleBodyPointerDown;
+    private arm;
+    private handlePointerMove;
+    private engage;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private disarm;
+    /**
+     * iOS: `touch-action` is frozen at gesture start and preventDefault on
+     * pointermove does not stop native scrolling — only a non-passive touchmove
+     * listener can claim the gesture from a scrollable body.
+     */
+    private touchBlocker;
+    private attachTouchBlocker;
+    private detachTouchBlocker;
+    render(): any;
+}

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

@@ -3,7 +3,7 @@
  */
 export declare class CoButton {
     /** Visual style */
-    variant: 'primary' | 'secondary' | 'stroke' | 'ghost';
+    variant: 'primary' | 'secondary' | 'stroke' | 'ghost' | 'danger' | 'success';
     /** Shape: pill or straight corners */
     shape: 'rounded' | 'square';
     /** Size */
@@ -24,6 +24,8 @@ export declare class CoButton {
     color?: string;
     /** Custom text/icon color (CSS value or token, e.g. "var(--co-color-base-blanco)") */
     textColor?: string;
+    /** Override the size-derived glyph px (e.g. 24). Falls back to the size default. */
+    iconSize?: number;
     el: HTMLElement;
     private handleClick;
     render(): any;

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

@@ -0,0 +1,83 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * Month grid for the event calendar. Forks the day grid, roving-tabindex and
+ * keyboard model from `co-calendar`, then overlays multi-day event bars laid out
+ * by `layoutMonth` from the engine. Presentation + interaction only; the host
+ * (via `co-event-calendar`) owns data and persistence.
+ *
+ * Events are CONTROLLED through the `events` prop — drag emits a request, it does
+ * NOT mutate locally; the host re-renders with new data on success or leaves the
+ * old data on failure (that IS the revert).
+ *
+ * @part grid - The month grid container
+ */
+export declare class CoCalendarMonth {
+    el: HTMLElement;
+    /** Normalized events to render (from the engine's `normalizeEvents`). */
+    events: NormalizedEvent[];
+    /** Year shown. */
+    year: number;
+    /** Month shown (1-12). */
+    month: number;
+    /** BCP-47 locale for weekday labels. */
+    locale: string;
+    /** First day of week, 0=Sun..6=Sat. */
+    firstDayOfWeek: number;
+    /** IANA timezone used to place timed events on their wall-clock day. */
+    timeZone: string;
+    /** Earliest interactable day "YYYY-MM-DD" (gates select/drag — past-block). */
+    minDate?: string;
+    /** Latest interactable day "YYYY-MM-DD". */
+    maxDate?: string;
+    /** Master interaction gate. */
+    editable: boolean;
+    /** Allow empty-day click to request a create. */
+    selectable: boolean;
+    /** Max event lanes per day before "+N more". */
+    maxLanes: number;
+    /** 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;
+    /** Emitted when an empty day is selected (create request). Detail = "YYYY-MM-DD". */
+    coDaySelect: EventEmitter<{
+        date: string;
+    }>;
+    /** Emitted when an event chip is activated. */
+    coEventClick: EventEmitter<{
+        id: string;
+    }>;
+    /** Emitted on a completed drag-move (day granularity). */
+    coEventDrop: EventEmitter<{
+        id: string;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+    }>;
+    /** Emitted when the "+N more" affordance is activated. */
+    coMoreClick: EventEmitter<{
+        date: string;
+    }>;
+    private onPointerUp;
+    componentWillLoad(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private defaultFocus;
+    private get matrix();
+    private eventById;
+    private isDayInteractable;
+    private selectDay;
+    private activateEvent;
+    private moveFocus;
+    private focusCell;
+    private handleKeyDown;
+    private startDrag;
+    private finishDrag;
+    private renderChip;
+    render(): any;
+}

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

@@ -19,7 +19,7 @@ export declare class CoChip {
     /** Visual variant */
     variant: 'filled' | 'outlined';
     /** Semantic color */
-    color: 'default' | 'primary' | 'success' | 'error' | 'warning' | 'info';
+    color: 'default' | 'primary' | 'success' | 'error' | 'warning' | 'info' | 'pending' | 'progress' | 'review' | 'submitted';
     /** Text label (alternative to default slot) */
     label?: string;
     /** Icon name for the left icon (prop-based, uses co-icon — any Phosphor icon name) */
@@ -28,8 +28,13 @@ export declare class CoChip {
     iconRight?: string;
     /** Icon weight applied to prop-based iconLeft / iconRight. */
     iconWeight: 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
-    /** Show dismiss/remove button and emit coRemove on click */
+    /** Show dismiss/remove button and emit coRemove on click. Reflected so it
+     *  survives lazy hydration when set via a framework wrapper. */
     removable: boolean;
+    /** Show a leading colour dot (status/value colour). Reflected for hydration. */
+    dot: boolean;
+    /** Colour of the leading dot (hex or any CSS colour). Reflected for hydration. */
+    dotColor?: string;
     /** Make the chip clickable (emits coClick) */
     clickable: boolean;
     /** Disabled state */

package/dist/types/components/co-color-picker/co-color-picker.d.ts

@@ -27,6 +27,8 @@ export declare class CoColorPicker {
     helperText?: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input): s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
     /** Field name for form submission. */
     name?: string;
     /**

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

@@ -1,10 +1,5 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-export interface CommandItem {
-    label: string;
-    icon?: string;
-    value: string;
-    section?: string;
-}
+import { CommandItem } from './commandSearchGroup';
 /**
  * A command palette / search component (⌘K style).
  * Opens as an overlay with a search input and filterable list of items.
@@ -21,18 +16,56 @@ export declare class CoCommandSearch {
     items: string | CommandItem[];
     /** Empty state message when no results match */
     emptyMessage: string;
+    /** When true, the host supplies already-filtered, ordered items: disable
+     *  internal client filtering so fetch-as-you-type results pass through. */
+    async: boolean;
+    /** Show a loading indicator in the results area (async fetch in flight). */
+    loading: boolean;
+    /** Facet chips as JSON string: [{label:string, icon?:string}[]] */
+    chips: string;
+    /** Module tabs (mac-Spotlight style) as JSON: [{value,label,icon}]. Empty = no tabs row. */
+    tabs: string;
+    /** The active tab's value (the scope model key), or '' = no active tab. */
+    activeTab: string;
+    /** Show the "Más ▾" overflow tab. */
+    hasMore: boolean;
+    /** Label for the overflow tab. */
+    moreLabel: string;
+    /** Favorites / shortcuts grid (mac-Spotlight app grid) as JSON: [{value,label,icon,color}].
+     *  Shown as a grid at the top of the results, only while the query is empty. */
+    favorites: string;
     private query;
     private activeIndex;
     coSelect: EventEmitter<string>;
     coClose: EventEmitter<void>;
+    coQueryChange: EventEmitter<string>;
+    /** Emitted when an item with keepOpen=true is selected. Detail = item.value (scope model key). */
+    coScopeChange: EventEmitter<string>;
+    /** Emitted when Backspace is pressed with an empty query, or when the scope chip ✕ is clicked.
+     *  Detail = current query string (always '' at emit time). Host decides: pop scope or remove last facet. */
+    coBackspaceEmpty: EventEmitter<string>;
+    /**
+     * Emitted when the user clicks ✕ on a facet chip.
+     * detail = chip index (number).
+     */
+    coChipRemove: EventEmitter<number>;
+    /** Emitted when a module tab is clicked. detail = tab value; '' when the active tab is re-clicked (deselect). */
+    coTabSelect: EventEmitter<string>;
+    /** Emitted when the "Más ▾" overflow tab is clicked. */
+    coMoreTabs: EventEmitter<void>;
     private inputEl?;
     private get parsedItems();
     private get filteredItems();
+    private get parsedChips();
+    private get parsedTabs();
+    private get parsedFavorites();
     /** Item label with the matched substring wrapped for highlighting. */
     private renderLabel;
+    onActiveTabChange(newVal: string): void;
     onOpenChange(newVal: boolean): void;
     private handleInput;
     private handleKeyDown;
+    /** Two-stage commit: keepOpen items emit coScopeChange only; all others emit coSelect + close. */
     private selectItem;
     private close;
     private handleOverlayClick;

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

@@ -0,0 +1,20 @@
+export interface CommandItem {
+    label: string;
+    value: string;
+    icon?: string;
+    subtitle?: string;
+    section?: string;
+    /** When true, selectItem emits coScopeChange only (no coSelect, no close). Two-stage commit. */
+    keepOpen?: boolean;
+}
+export type RenderRow = {
+    kind: 'header';
+    label: string;
+} | {
+    kind: 'item';
+    item: CommandItem;
+    index: number;
+};
+/** Flatten an ordered CommandItem[] into render rows, inserting a header
+ *  whenever the section changes. `index` counts items only (drives activeIndex). */
+export declare function groupItems(items: CommandItem[]): RenderRow[];

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

@@ -0,0 +1,17 @@
+import { CommandItem } from './commandSearchGroup.js';
+/**
+ * Pure: should the component keep open and emit coScopeChange
+ * instead of the default coSelect+close?
+ */
+export declare function shouldKeepOpen(item: CommandItem): boolean;
+/**
+ * Pure: should coBackspaceEmpty fire?
+ * True when the user presses Backspace with an empty query.
+ */
+export declare function isEmptyBackspace(key: string, query: string): boolean;
+/**
+ * Pure: client-side item filtering.
+ * Mirrors the filteredItems getter logic from co-command-search.tsx.
+ * When async=true all items pass through (host already filtered them).
+ */
+export declare function applyClientFilter(items: CommandItem[], query: string, async: boolean): CommandItem[];

package/dist/types/components/co-data-table/co-data-table.d.ts

@@ -42,7 +42,7 @@ export declare class CoDataTable {
     /** Emitted when a column sort is requested */
     coSort: EventEmitter<{
         field: string;
-        order: 'asc' | 'desc';
+        order: 'asc' | 'desc' | '';
     }>;
     /** Emitted when a row is selected/deselected */
     coRowSelect: EventEmitter<{
@@ -98,6 +98,7 @@ export declare class CoDataTable {
     private getColumnWidth;
     private getTableWidth;
     private renderColgroup;
+    private renderSortIcon;
     private renderHeader;
     private renderBody;
     private renderEmpty;

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

@@ -0,0 +1,110 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * 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
+ * calendar emits requests (`coEventDrop`, `coDateSelect`) and the host applies
+ * them by updating the `events` prop — leaving it unchanged on failure is the
+ * revert.
+ *
+ * Instants are ISO-8601 strings WITH offset/Z (timed) or "YYYY-MM-DD" (all-day);
+ * the calendar never exposes Date objects. `timeZone` controls wall-clock render.
+ *
+ * @part toolbar - The header toolbar
+ * @part body - The active view container
+ */
+export declare class CoEventCalendar {
+    /** Active view. Phase 1 ships `month`; week/day/agenda land in later phases. */
+    view: 'month' | 'week' | 'day' | 'agenda';
+    /** Anchor date "YYYY-MM-DD" controlling the visible period. Persisted by host. */
+    date?: string;
+    /** Events: an array or a JSON string (raw-HTML use). */
+    events: CoCalendarEvent[] | string;
+    /** BCP-47 locale for labels. */
+    locale: string;
+    /** IANA timezone for wall-clock rendering. Defaults to the browser zone. */
+    timeZone?: string;
+    /** Master interaction gate (per-event `editable` can still lock individuals). */
+    editable: boolean;
+    /** Allow empty-day selection to request a create. */
+    selectable: boolean;
+    /** Max event lanes per day before "+N more". */
+    dayMaxEvents: number;
+    /** Earliest interactable day "YYYY-MM-DD" (past-block). */
+    minDate?: string;
+    /** Latest interactable day "YYYY-MM-DD". */
+    maxDate?: string;
+    /** First day of week, 0=Sun..6=Sat. */
+    firstDayOfWeek: number;
+    /** 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;
+    /** Default minutes for a timed event missing an end. */
+    defaultDurationMinutes: number;
+    /** Internal anchor (YYYY-MM-DD) — mirrors `date`, defaults to today. */
+    anchor: string;
+    /** An event chip was activated. */
+    coEventClick: EventEmitter<{
+        event: NormalizedEvent;
+    }>;
+    /** A date/range was selected (create request). */
+    coDateSelect: EventEmitter<{
+        start: string;
+        end: string;
+        allDay: boolean;
+    }>;
+    /** An event was dragged to a new time (move). `revert` is a host convenience. */
+    coEventDrop: EventEmitter<{
+        event: NormalizedEvent;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+        revert: () => void;
+    }>;
+    /** The visible period changed → host should refetch and persist the view pref. */
+    coDatesSet: EventEmitter<{
+        view: string;
+        start: string;
+        end: string;
+        activeDate: string;
+    }>;
+    /** The active view changed. */
+    coViewChange: EventEmitter<{
+        view: string;
+    }>;
+    /** "+N more" was activated for a day. */
+    coMoreClick: EventEmitter<{
+        date: string;
+        events: NormalizedEvent[];
+    }>;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    onDateChange(value?: string): void;
+    private get tz();
+    private get normalized();
+    private get viewsList();
+    /** Visible [start, end) of the current month view, as date strings. */
+    private visibleRange;
+    private emitDatesSet;
+    private setAnchor;
+    private goToday;
+    private goPrev;
+    private goNext;
+    private step;
+    private switchView;
+    private handleDaySelect;
+    private handleEventClick;
+    private handleEventDrop;
+    private handleMoreClick;
+    private title;
+    render(): any;
+}

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

@@ -1,4 +1,4 @@
-export type IconWeight = 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
+import { type IconWeight } from './iconLoader';
 /**
  * co-icon — Phosphor icon renderer.
  *

package/dist/types/components/co-icon/iconLoader.d.ts

@@ -0,0 +1,6 @@
+export type IconWeight = 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
+/**
+ * Devuelve (y cachea) la PROMESA del SVG para `(weight, name)`. Las llamadas
+ * concurrentes para el mismo icono comparten un único fetch.
+ */
+export declare function loadSvg(name: string, weight: IconWeight): Promise<string>;

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

@@ -19,5 +19,7 @@ export declare class CoIconButton {
     icon?: string;
     /** Icon weight */
     iconWeight: 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
+    /** Override the size-derived glyph px (e.g. 24). Falls back to the size default. */
+    iconSize?: number;
     render(): any;
 }

package/dist/types/components/co-json-field/co-json-field.d.ts

@@ -37,6 +37,9 @@ export declare class CoJsonField {
     invalidMessage: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input paddings; mono font scales 12/13/13/14).
+     *  Vertical extent still comes from `rows`. */
+    size: 's' | 'sm' | 'md' | 'lg';
     /** Emitted on every keystroke with the raw text. */
     coInput: EventEmitter<string>;
     /** Emitted with the committed text on blur. */