@prolibu-suite/cobalt-core 0.2.0 → 0.4.0

package/dist/types/components/co-option-list/optionListLogic.d.ts

@@ -0,0 +1,69 @@
+export interface OptionListItem {
+    _id: string;
+    label: string;
+    /** Colorea el label (categorías con color propio). */
+    labelColor?: string;
+    /** Subline muted (p.ej. email). */
+    description?: string;
+    /** Texto secundario junto al label, renderizado como "- suffix". */
+    suffix?: string;
+    /** Pill junto al label (generaliza el workspace badge de suite-v2). */
+    badge?: {
+        label: string;
+        color?: string;
+    };
+    /** Phosphor icon como leading visual (si no hay avatar/color). */
+    icon?: string;
+    /** Color del dot / ring del avatar. */
+    color?: string;
+    /** Iniciales del avatar. */
+    avatar?: string;
+    /** URL de imagen del avatar. */
+    image?: string;
+    /** Header de sección: se inserta uno al CAMBIAR de group (patrón ⌘K). */
+    group?: string;
+    disabled?: boolean;
+}
+export type OptionListRow = {
+    kind: 'header';
+    label: string;
+} | {
+    kind: 'item';
+    item: OptionListItem;
+    index: number;
+};
+export declare function parseItems(raw: string | OptionListItem[]): OptionListItem[];
+export declare function parseValue(raw: string): string[];
+/**
+ * Selected-first contra el snapshot tomado al abrir (patrón co-ref-field):
+ * idle → bloque seleccionado en orden de snapshot (sintetizando desde
+ * snapshotDisplay los que la página actual no contiene) + resto en orden de
+ * server; buscando → solo resultados reales, seleccionados primero.
+ *
+ * Invariante: todo id en `snapshotIds` DEBE tener una entrada correspondiente
+ * en `snapshotDisplay` (armado por el caller desde selectedItems ∪ items al
+ * tomar el snapshot). Un id sin display-item asociado se cae silenciosamente
+ * de la lista en modo idle (el `byId.get(d._id) ?? d` sintetiza desde el
+ * display-item mismo, pero no hay nada que sintetizar si el id nunca entró a
+ * snapshotDisplay en primer lugar).
+ */
+export declare function orderItems(items: OptionListItem[], snapshotIds: Set<string>, snapshotDisplay: OptionListItem[], searching: boolean): OptionListItem[];
+/** Aplana a filas de render insertando un header cuando `group` cambia
+ *  (groupItems de co-command-search). `index` cuenta solo items. */
+export declare function buildRows(items: OptionListItem[]): OptionListRow[];
+/** Siguiente highlight: wrap, salta disabled. -1 = sin items navegables. */
+export declare function nextActiveIndex(current: number, delta: 1 | -1, items: OptionListItem[]): number;
+/** `total > 0` tiene precedencia (deriva remaining); si no, vale `hasMoreProp`. */
+export declare function deriveMore(count: number, total: number, hasMoreProp: boolean): {
+    hasMore: boolean;
+    remaining: number;
+};
+export declare const VIRTUAL_ITEM_HEIGHT = 34;
+export declare const VIRTUAL_VIEWPORT_ITEMS = 8;
+export declare const VIRTUAL_OVERSCAN = 3;
+export declare function virtualSlice(scrollTop: number, count: number): {
+    totalHeight: number;
+    startIdx: number;
+    endIdx: number;
+    offsetY: number;
+};

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

@@ -1,9 +1,54 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 export declare class CoOverlay {
+    el: HTMLElement;
     /** Whether the overlay is visible */
     open: boolean;
+    /**
+     * Opt-in accessible focus trap. When true, opening the overlay records the
+     * previously-focused element, moves focus into the overlay, cycles Tab /
+     * Shift+Tab within the slotted content, and restores focus on close.
+     * Default false → existing consumers are unchanged.
+     */
+    trapFocus: boolean;
+    /**
+     * Opt-in: emit `coClose` when Escape is pressed while open.
+     * Default false → existing consumers are unchanged.
+     */
+    closeOnEscape: boolean;
     /** Emitted when the overlay backdrop is clicked */
     coClose: EventEmitter<void>;
+    /** Slide/fade-out animation finished (overlay fully closed). */
+    coAfterClose: EventEmitter<void>;
+    /** Slide/fade-in animation finished (overlay fully open). */
+    coAfterOpen: EventEmitter<void>;
+    /** Whether THIS instance currently holds a scroll lock (prevents double-count). */
+    private hasLock;
+    /** The scrim element, promoted to the top layer via the Popover API. */
+    private overlayEl?;
+    /** Element focused before the trap engaged, restored on close. */
+    private returnFocusEl?;
+    onOpenChange(isOpen: boolean): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    private acquireLock;
+    private releaseLock;
+    /**
+     * Promote the scrim to the browser top layer so it covers the whole viewport
+     * regardless of ancestor `filter`/`mask`/`transform` (which would otherwise
+     * make `position: fixed` resolve against that ancestor, confining the scrim).
+     * The Popover API promotes WITHOUT moving the DOM node, so slots and Stencil
+     * reconciliation are untouched. No-ops gracefully where unsupported.
+     */
+    private syncPopover;
+    /** Record the current focus and move it into the overlay (guarded by trapFocus). */
+    private captureAndFocus;
+    /** Restore focus to the element that had it before the trap engaged. */
+    private restoreFocus;
+    /** Deepest active element, descending through nested shadow roots. */
+    private deepActiveElement;
+    handleKeydown(e: KeyboardEvent): void;
+    private trapTab;
     private handleClick;
+    private handleTransitionEnd;
     render(): any;
 }

package/dist/types/components/co-overlay/focusTrap.d.ts

@@ -0,0 +1,20 @@
+/** CSS selector matching natively tabbable elements. */
+export declare const FOCUSABLE_SELECTOR: string;
+/**
+ * Decide which focusable index a Tab / Shift+Tab keystroke should move to.
+ *
+ * @param count       number of focusable elements inside the trap
+ * @param activeIndex index of the currently focused element, or -1 when focus
+ *                    is outside the trap (e.g. it escaped to the body)
+ * @param shiftKey    whether Shift is held (backward tabbing)
+ * @returns the index to focus, or -1 when there is nothing to trap
+ *
+ * Pure — no DOM — so the wrap-around edge cases stay unit-testable.
+ */
+export declare function resolveTabIndex(count: number, activeIndex: number, shiftKey: boolean): number;
+/**
+ * Collect the tabbable elements slotted into the overlay's light DOM, skipping
+ * hidden / aria-hidden ones. (Focusables nested inside further shadow roots are
+ * out of scope — the common dialog/modal content lives in the slotted subtree.)
+ */
+export declare function getFocusableElements(root: ParentNode): HTMLElement[];

package/dist/types/components/co-overlay/overlayAfterClose.d.ts

@@ -0,0 +1,5 @@
+export type AfterEvent = 'after-open' | 'after-close' | null;
+/** Decide which after-animation event a `transitionend` should emit.
+ *  `watched` is the authoritative CSS property (so multi-prop transitions
+ *  — e.g. transform + opacity — fire the after-event exactly once). */
+export declare function afterEventFor(propertyName: string, isOpen: boolean, watched: string): AfterEvent;

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

@@ -26,6 +26,8 @@ export declare class CoPhoneField {
     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';
     /** Default country ISO2 code (e.g. "CO", "US"). Optional — if not set, starts empty. */
     defaultCountry: string;
     /** Emits the full phone string on change. */

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

@@ -36,6 +36,15 @@ export declare class CoPopover {
     private handleDocumentClickManual;
     private handleDocumentKeydownManual;
     private updatePosition;
+    /**
+     * Promote the panel to the browser top layer (Popover API) so an ancestor's
+     * filter / mask / overflow / transform can't clip it. Mirrors co-overlay.
+     * The API promotes WITHOUT moving the DOM node — slots, inherited custom
+     * properties, composedPath() outside-click and nested popovers all keep
+     * working. No-ops where unsupported (graceful fallback to in-place fixed
+     * positioning + offset-ancestor compensation, see updatePosition).
+     */
+    private promotePanel;
     private scheduleUpdate;
     private addScrollListeners;
     private cleanupListeners;

package/dist/types/components/co-progress-bar/co-progress-bar.d.ts

@@ -10,5 +10,7 @@ export declare class CoProgressBar {
     variant: 'solid' | 'dashed';
     /** Height of the bar in px */
     thickness: number;
+    /** Indeterminate mode: ignore `value` and run a looping sweep animation. */
+    indeterminate: boolean;
     render(): any;
 }

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

@@ -24,6 +24,8 @@ export declare class CoRefField {
     /** Whether the field is required (renders a required marker on the label). */
     required: boolean;
     secondaryLabel?: string;
+    /** Phosphor icon name rendered before the label text. */
+    labelIcon?: string;
     placeholder: string;
     disabled: boolean;
     clearable: boolean;
@@ -33,8 +35,15 @@ export declare class CoRefField {
     iconLeft?: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
-    /** Size of the trigger. 'sm' reduces height to 32px. */
-    size: 'default' | 'sm';
+    /**
+     * Size of the trigger (mirrors co-input): s 28 / sm 32 / md 40 / lg 48.
+     *
+     * `'default'` is a deprecated alias of `'md'`, kept for backwards
+     * compatibility with the old `'default' | 'sm'` scale — use `'md'` instead.
+     */
+    size: 's' | 'sm' | 'md' | 'lg' | 'default';
+    /** Common-scale size with the legacy `'default'` alias normalized to `'md'`. */
+    private get normalizedSize();
     /** Selected value: single ID string or JSON array of IDs. */
     value: string;
     /** JSON array of options to display: RefFieldOption[] */
@@ -66,6 +75,12 @@ export declare class CoRefField {
     maxChips: number;
     /** Panel color theme. 'auto' follows trigger, 'dark' forces dark panel, 'light' forces light. */
     panelTheme: 'auto' | 'dark' | 'light';
+    /**
+     * Shape of the leading avatar (selected value + option rows). Defaults to
+     * 'circle' (people refs); use 'square' for company/workspace refs — it renders
+     * a smooth squircle. The avatar border can be themed via --co-avatar-border-color.
+     */
+    avatarShape: 'circle' | 'square';
     coChange: EventEmitter<{
         value: string | string[];
         item: RefFieldOption;

package/dist/types/components/co-rich-text-editor/co-rich-text-editor.d.ts

@@ -23,8 +23,6 @@ export declare class CoRichTextEditor {
     label?: string;
     secondaryLabel?: string;
     helperText?: string;
-    /** Label layout: vertical (label above) or horizontal (label beside) */
-    layout: 'vertical' | 'horizontal';
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
     disabled: boolean;
     readonly: boolean;
@@ -44,6 +42,41 @@ export declare class CoRichTextEditor {
     customExtensions?: object[];
     /** Host image upload handler (JS property): `(file) => Promise<url>`. */
     imageUpload?: (file: File) => Promise<string>;
+    /**
+     * Font families available in the bubble menu font selector.
+     * JS property: `Array<{ label: string; value: string }>`.
+     * HTML attribute: JSON string of the same array.
+     * If not provided, a default list of system fonts is used.
+     */
+    fontFamilies?: string | {
+        label: string;
+        value: string;
+    }[];
+    /**
+     * Account/imported fonts shown in a separate "Imported fonts" section.
+     * JS property: `Array<{ label: string; value: string }>`.
+     * HTML attribute: JSON string of the same array.
+     */
+    accountFonts?: string | {
+        label: string;
+        value: string;
+    }[];
+    /** Whether account fonts are currently loading. */
+    fontsLoading?: boolean;
+    /**
+     * Async callback that loads account/imported fonts.
+     * Called once when the font dropdown opens for the first time.
+     * Must return `Array<{ label: string; value: string; url?: string }>`.
+     * If `url` is provided, the font is registered via FontFace API.
+     * JS property only — cannot be set via HTML attribute.
+     */
+    fontLoader?: () => Promise<{
+        label: string;
+        value: string;
+        url?: string;
+    }[]>;
+    /** BCP-47 locale for UI strings (e.g. 'en', 'es-CO', 'pt-BR'). Default English. */
+    locale: string;
     /** Emitted on every keystroke. */
     coInput: EventEmitter<RichTextOutput>;
     /** Emitted on blur (committed value). */
@@ -53,23 +86,56 @@ export declare class CoRichTextEditor {
     coClear: EventEmitter<void>;
     /** Emitted once the editor is mounted and ready. */
     coReady: EventEmitter<void>;
+    /** Emitted when the font dropdown opens — host should load account fonts. */
+    coFontPopupShow: EventEmitter<void>;
+    /** Emitted when the font dropdown closes. */
+    coFontPopupHide: EventEmitter<void>;
     ready: boolean;
     hasFocus: boolean;
-    charCount: number;
+    /** Character count — updated imperatively to avoid re-renders on every keystroke. */
+    private charCount;
+    private charCountEl?;
     private editor?;
     private contentEl?;
     private toolbarEl?;
-    /** Last value we emitted — guards the value Watch against feedback loops. */
-    private lastEmitted;
+    private bubbleEl?;
+    private bubbleLinkFormEl?;
+    private bubbleLinkInputEl?;
+    private bubbleLinkUnlinkEl?;
+    private bubbleDragged;
+    private bubbleDragOffset;
+    private bubbleDragPos;
+    private bubbleDragMoveHandler?;
+    private bubbleDragEndHandler?;
+    private bubbleOutsideClickHandler?;
+    /** Position lock — prevents floating-ui from repositioning the bubble during toolbar interactions. */
+    private bubblePositionLocked;
+    private bubbleLockPos;
+    private bubbleLockTimer?;
+    private bubbleStyleObserver?;
+    private applyingBubbleLock;
+    /** Cached render function for font dropdown (re-invoked when accountFonts changes). */
+    private _fontDropdownRenderFn?;
+    private _fontDropdownSearchInput?;
+    /** Account fonts loaded via fontLoader callback. */
+    private _loadedAccountFonts;
+    private _fontLoaderCalled;
+    private _fontLoaderLoading;
+    /** Last emitted JSON string — guards the value Watch against feedback loops. */
+    private lastEmittedJson;
+    /** Last emitted HTML string — parents often send HTML back via value prop. */
+    private lastEmittedHtml;
     /** True while applying an external value (suppresses emit). */
     private applyingExternal;
-    private rt?;
-    /** Set by disconnectedCallback — aborts editor creation if the element was
-     *  removed while the lazy import was still in flight (ProseMirror leak). */
-    private destroyed;
+    private rt;
+    private blurTimeout?;
+    /** Image layout floating toolbar. */
+    private imgLayoutEl?;
+    private imgLayoutVisible;
     componentDidLoad(): Promise<void>;
     disconnectedCallback(): void;
     componentDidRender(): void;
+    onAccountFontsChange(): void;
     onValueChange(next: string | null): void;
     onEditableChange(): void;
     getJSON(): Promise<object | null>;
@@ -79,6 +145,8 @@ export declare class CoRichTextEditor {
     focusEditor(): Promise<void>;
     setContent(content: string | object): Promise<void>;
     getEditorInstance(): Promise<Editor | null>;
+    /** Whether the image node is enabled (mirrors presets.ts `wantImage` logic). */
+    private get imagesEnabled();
     private get parsedFeatures();
     private parseValue;
     private sanitizeHtml;
@@ -86,9 +154,93 @@ export declare class CoRichTextEditor {
     private handleUpdate;
     private handleFocus;
     private handleBlur;
+    /** Lock the bubble position so floating-ui doesn't reposition it. */
+    private lockBubblePosition;
+    /** Apply fixed position to the bubble, overriding floating-ui. */
+    private applyBubbleFixedPosition;
+    /** Watch for floating-ui style changes and override them when locked/dragged. */
+    private setupBubbleStyleObserver;
+    /**
+     * Hide/show the selection bubble while a toolbar dropdown is open. Uses a
+     * class with `!important` so it wins over the BubbleMenu plugin's inline
+     * display/visibility writes. When unsuppressed, the plugin's own state
+     * (selection still active) reveals it again on the next update.
+     */
+    private suppressBubble;
+    /** Close all open sub-dropdowns inside the bubble. */
+    private closeBubbleDropdowns;
     private refreshCharCount;
     private syncToolbar;
     private get resolvedToolbar();
+    private static readonly DEFAULT_FONTS;
+    private get resolvedFontFamilies();
+    private get resolvedAccountFonts();
+    /** Register a font via FontFace API so it can be previewed. */
+    private static readonly _registeredFonts;
+    private registerFontFace;
+    /** Load account fonts via the fontLoader callback (called once). */
+    private loadFontsViaCallback;
     private get helperIcon();
+    /**
+     * Create the bubble menu element imperatively. BubbleMenu v3 manages
+     * the element via remove()/appendChild(), which conflicts with Stencil's
+     * virtual DOM reconciliation. By creating it outside the VDOM, Stencil
+     * won't recreate or interfere with the element.
+     */
+    private createBubbleElement;
+    /** Helper: create a separator span */
+    private createSep;
+    /**
+     * Position a dropdown above or below the trigger depending on available
+     * viewport space. Sets `data-position="above"|"below"` so CSS can flip.
+     */
+    private positionDropdown;
+    private positionPanelNearBubble;
+    /** Helper: create a toggle button for the bubble */
+    private createBubbleBtn;
+    /** Creates the font family dropdown with search for the bubble menu. */
+    private createBubbleFontFamilySelect;
+    /** Creates a compact dropdown-select for the bubble menu. */
+    private createBubbleSelect;
+    /** Creates a compact color picker button for the bubble menu. */
+    private createBubbleColorPicker;
+    /** Close all bubble popups EXCEPT the given element. */
+    private closeAllBubblePopups;
+    private addDragHeader;
+    /** Generic draggable panel factory. */
+    private createBubblePanel;
+    /** Font size panel with visual preview and custom input. */
+    private createBubbleFontSizePanel;
+    /** Font weight panel with two-column layout and visual preview. */
+    private createBubbleFontWeightPanel;
+    /** Line height panel with custom input. */
+    private createBubbleLineHeightPanel;
+    /** Letter spacing panel with custom input. */
+    private createBubbleLetterSpacingPanel;
+    /** Background color panel for overflow menu. */
+    private createBubbleBgColorPanel;
+    /** Overflow menu (three-dots ⋮) with dynamic table context section. */
+    private createBubbleOverflowMenu;
+    private toggleBubbleLinkForm;
+    private submitBubbleLinkImperative;
+    private updateBubbleActiveStates;
+    private static readonly IMG_LAYOUT_ICONS;
+    private createImageLayoutBar;
+    private setImageLayout;
+    private getSelectedImageInfo;
+    /**
+     * Tag every image container with its layout mode (`data-image-layout`) so the
+     * stylesheet's responsive rules apply, and clear any stray inline positioning
+     * left over from legacy absolute-positioned content. Layout is CSS-only now
+     * (it reflows and collapses on mobile); we only set the attribute here.
+     *
+     * Runs on every transaction. The resize NodeView's `onUpdate` returns `true`,
+     * so ProseMirror never reflects attribute changes to the DOM — we must read
+     * from state and write the attribute imperatively to the container.
+     */
+    private syncImageLayouts;
+    /** Reposition only the layout bar (used during drag for performance). */
+    private updateImageLayoutBarPosition;
+    private updateImageLayoutBar;
     render(): any;
 }

package/dist/types/components/co-rich-text-toolbar/co-rich-text-toolbar.d.ts

@@ -1,42 +1,148 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import type { Editor, ToolbarItem } from '@prolibu-suite/cobalt-rich-text';
+import type { Editor, ToolbarEntry } from '@prolibu-suite/cobalt-rich-text';
 /**
  * Formatting toolbar for co-rich-text-editor. Receives the Tiptap editor
  * instance via the `editor` JS property, runs commands, and reflects active
- * state. Can also be placed standalone and wired to any editor instance.
+ * state. Supports separators, dropdown menus, inline popover inputs, and
+ * color palette pickers.
  *
  * @part toolbar - The toolbar container
  * @part button - A toolbar button
  */
 export declare class CoRichTextToolbar {
+    el: HTMLElement;
     /** Editor instance (set as a property by the host editor). */
     editor?: Editor;
     /** Toolbar layout variant. */
     variant: 'none' | 'compact' | 'basic' | 'full';
     disabled: boolean;
+    /** BCP-47 locale for UI strings (e.g. 'en', 'es-CO', 'pt-BR'). Default English. */
+    locale: string;
+    /** Image upload handler (JS property): `(file) => Promise<url | {src, fileId}>`. */
+    imageUpload?: (file: File) => Promise<any>;
     /** Emitted whenever a toolbar action runs (observability for hosts). */
     coAction: EventEmitter<{
         action: string;
         payload?: unknown;
     }>;
-    items: ToolbarItem[];
+    /** Emitted when a toolbar popover/dropdown opens or closes (host hides the
+     *  selection bubble while one is open to avoid spatial overlap). */
+    coPopoverChange: EventEmitter<{
+        open: boolean;
+    }>;
+    items: ToolbarEntry[];
     /** Bumped on every editor transaction to refresh active state. */
     tick: number;
+    /** Currently open popover/dropdown (action id) or null. */
+    openPopover: string | null;
+    /** Input value for popover forms (link URL, image URL, etc.). */
+    popoverInput: string;
+    /** Table grid picker state. */
+    gridHoverRows: number;
+    gridHoverCols: number;
+    gridLockedRows: number;
+    gridLockedCols: number;
+    tableTab: 'grid' | 'manual';
+    tableManualRows: number;
+    tableManualCols: number;
+    tableWithHeader: boolean;
+    /** Table context items shown when cursor is inside a table. */
+    tableContextItems: ToolbarEntry[];
+    /** Image popover sub-view: 'menu' shows options, 'url' shows URL input. */
+    imagePopoverMode: 'menu' | 'url';
+    /** Hex input for toolbar color picker. */
+    colorHexInput: string;
     private onTransaction;
-    componentWillLoad(): Promise<void>;
-    onVariantChange(v: string): Promise<void>;
+    private colorPalette;
+    private _tableContextItems;
+    private get s();
+    private tItem;
+    private tOpt;
+    /**
+     * Prevent toolbar clicks from stealing focus from the editor.
+     * This handler is on the HOST element (light DOM), which reliably
+     * prevents focus change even when Shadow DOM retargets events.
+     */
+    private handleHostMouseDown;
+    private handleDocumentClick;
+    connectedCallback(): void;
+    componentWillLoad(): void;
+    onVariantChange(v: string): void;
     onEditorChange(next?: Editor, prev?: Editor): void;
+    /**
+     * Command whose presence in the schema proves an item's extension is loaded.
+     * Items without an entry have no extension dependency (separators, core marks,
+     * link, paragraph/heading, undo/redo, text color) and are always shown.
+     */
+    private static readonly ITEM_COMMAND;
+    /**
+     * Resolve a variant to the items actually usable in the current editor:
+     * hide any control whose extension the active preset didn't load, then
+     * collapse the separators left dangling by the removals. Until the editor is
+     * wired we can't inspect the schema, so the full variant is shown and
+     * re-filtered from `onEditorChange`.
+     */
+    private resolveItems;
+    onOpenPopoverChange(next: string | null, prev: string | null): void;
     disconnectedCallback(): void;
+    private updateTableContext;
+    private isSeparator;
     private isActive;
+    /** Toolbar icon that reflects current state (e.g. alignment shows the active alignment). */
+    private getDynamicIcon;
     private run;
-    /** Accept only fetchable URL schemes from the prompt (no javascript: etc.). */
-    private static safeUrl;
-    private toggleLink;
-    private insertImage;
-    /** Hide buttons whose node/mark isn't in the editor's schema — e.g. the
-     *  image button on the `full` toolbar with a preset that has no image node
-     *  (clicking it would call an unregistered command and throw). */
-    private supportedBySchema;
+    private togglePopover;
+    private closePopover;
+    private submitPopover;
+    private smoothScrollToInserted;
+    private removeLink;
+    private removeIframe;
+    private selectColor;
+    private clearColor;
+    /**
+     * Whether an action is allowed in the current selection. Beyond undo/redo,
+     * this disables commands that would produce content the editor can't
+     * represent — most importantly the Table button while the cursor is already
+     * inside a table, since nested tables are invalid and corrupt the document
+     * when it's reloaded (tiptap throws "Invalid HTML content" on such markup).
+     *
+     * Each command is probed through tiptap's `can()` dry-run, so a button also
+     * disables automatically anywhere ProseMirror's schema would reject it (e.g.
+     * marks inside a code block). The probe defaults to enabled on any error or
+     * unknown command so a quirk never makes a control silently disappear.
+     */
+    /**
+     * Whether an action can run *right now*. Extension availability is already
+     * handled by `resolveItems` (unavailable controls aren't rendered), so this
+     * only covers the dynamic, cursor-dependent cases: the hard "no table inside
+     * a table" rule, and position validity (e.g. marks inside a code block) via
+     * tiptap's `can()` dry-run. A thrown dry-run defaults to enabled so a quirk
+     * never makes a visible control silently lock up.
+     */
     private canRun;
+    private getDropdownLabel;
+    private getActiveColor;
+    private renderButton;
+    private renderAlignmentGroup;
+    private renderColorButton;
+    /** Visual grid of list-marker styles (Google-Docs style). */
+    private renderListPicker;
+    /** Visual picker for task-list variants (checkboxes; strike vs plain). */
+    private renderTaskListPicker;
+    private applyListStyle;
+    private applyTaskStyle;
+    private renderInputPopover;
+    private renderImagePopover;
+    private triggerImageFileUpload;
+    private isDropdownOptionActive;
+    /** Apply a free-form value typed into a dropdown's custom input. */
+    private applyDropdownCustom;
+    private renderDropdown;
+    private handleDropdownSelect;
+    private renderTableGrid;
+    private renderGridTab;
+    private renderManualTab;
+    private insertTable;
+    private renderColorPicker;
     render(): any;
 }

package/dist/types/components/co-rich-text-viewer/co-rich-text-viewer.d.ts

@@ -1,13 +1,4 @@
 import type { RichTextPreset } from '@prolibu-suite/cobalt-rich-text';
-/**
- * Read-only renderer for rich-text content. For `format="html"` it only runs
- * the package's canonical sanitizer (the `/sanitizer` subpath has no Tiptap
- * import → tiny). `format="json"` lazily pulls the serializer to turn a
- * ProseMirror document into sanitized HTML.
- *
- * @part content - The rendered content container
- * @part empty - The empty-state element
- */
 export declare class CoRichTextViewer {
     /** HTML string (default) or ProseMirror JSON string. */
     value: string | null;
@@ -15,10 +6,6 @@ export declare class CoRichTextViewer {
     format: 'html' | 'json';
     /** Sanitization profile to apply. */
     preset: RichTextPreset;
-    /** Feature overrides used when the content was authored with them (JSON
-     *  string for HTML attr, or object via JS property) — keeps the whitelist
-     *  in lock-step with the editor that produced the content. */
-    features?: string | object;
     /** Text shown when there is no content. */
     emptyText?: string;
     /** Reduced padding. */
@@ -26,7 +13,7 @@ export declare class CoRichTextViewer {
     html: string;
     componentWillLoad(): Promise<void>;
     watchInputs(): Promise<void>;
-    private get parsedFeatures();
+    private sanitizeHtml;
     private compute;
     render(): any;
 }