@prolibu-suite/cobalt-core 0.2.0 → 0.4.0

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

@@ -0,0 +1,32 @@
+/** A single contiguous segment of the bar. */
+export interface CoSegment {
+    /** Portion of `total` this segment fills. */
+    value: number;
+    /** Any CSS color / token, e.g. `var(--co-color-primary-azul)`. */
+    color: string;
+    /** Optional label (used as the segment `title` tooltip). */
+    label?: string;
+}
+/**
+ * A stacked, multi-segment meter — a pill track split into N contiguous
+ * colored segments (e.g. a storage breakdown). Display-only; colors are
+ * supplied by the consumer. Provide an external legend via `slot="legend"`.
+ */
+export declare class CoSegmentedBar {
+    /** Track height in px. */
+    thickness: number;
+    /** Corner rounding of the track. `full` = pill. */
+    radius: 'full' | 'sm' | 'lg';
+    /** Background color of the empty track. */
+    trackColor: string;
+    /** The value the segments are measured against (100% = full track). */
+    total: number;
+    /**
+     * Segments to render — a JSON string OR an array of
+     * `{ value: number; color: string; label?: string }`.
+     */
+    segments: string | CoSegment[];
+    /** Normalize the `segments` prop (JSON string or array) to a clean array. */
+    private get parsedSegments();
+    render(): any;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Placeholder de carga con shimmer (sweep). Componer apilando varios.
+ * Respeta prefers-reduced-motion (sin animación).
+ */
+export declare class CoSkeleton {
+    /** rect (default) | text (radio menor) | circle */
+    variant: 'rect' | 'text' | 'circle';
+    /** Ancho CSS (default 100%) */
+    width: string;
+    /** Alto CSS (default por variante en CSS) */
+    height: string;
+    render(): any;
+}

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

@@ -8,6 +8,10 @@ export declare class CoTab {
     selected: boolean;
     /** Size */
     size: 'large' | 'small';
+    /** Visual variant: filled pill (default) or underline tab */
+    variant: 'pill' | 'underline';
+    /** Optional count/badge pill rendered after the label */
+    badge?: string;
     /** Left icon (Phosphor name) */
     iconLeft?: string;
     /** Right icon (Phosphor name) */

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

@@ -3,10 +3,13 @@ export declare class CoTabGroup {
     el: HTMLElement;
     /** Currently selected tab value */
     value?: string;
+    /** Visual variant, propagated to slotted co-tab children */
+    variant: 'pill' | 'underline';
     /** Emitted when the active tab changes */
     coTabChange: EventEmitter<string>;
     onTabSelect(e: CustomEvent<string>): void;
     watchValue(): void;
+    watchVariant(): void;
     componentDidLoad(): void;
     private syncTabs;
     render(): any;

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

@@ -43,6 +43,8 @@ export declare class CoTagsField {
     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';
     /** Emitted with the full array on every add/edit/remove/clear. */
     coChange: EventEmitter<string[]>;
     /** Emitted on every keystroke of the inline input with the raw text. */

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

@@ -39,6 +39,9 @@ export declare class CoTextarea {
     helperText?: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input paddings/font: s / sm / md / lg).
+     *  Vertical extent still comes from `rows`. */
+    size: 's' | 'sm' | 'md' | 'lg';
     /** Show clear button when textarea has value */
     clearable: boolean;
     /** Resize behavior of the textarea */

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

@@ -25,6 +25,13 @@ export declare class CoToast {
     actionsLayout: CoToastActionsLayout;
     /** Semantic variant — drives left accent color, icon tint, default icon, and announced ARIA role. */
     variant: CoToastVariant;
+    /**
+     * Determinate upload/loading progress (0–100). When set, a progress track is
+     * rendered below the message row (with a percentage label, and an
+     * `upload-simple` azul icon when no `icon` is provided). Leave undefined for
+     * a plain toast — behaviour is unchanged.
+     */
+    progress?: number;
     /** Emitted when dismiss is clicked */
     coDismiss: EventEmitter<void>;
     render(): any;

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

@@ -7,6 +7,12 @@ export declare class CoToggleButton {
     iconRight?: string;
     size: 'l' | 'm' | 's' | 'xs';
     disabled: boolean;
+    /** Visual variant. 'track' renders the button as a detached rounded pill for a
+     *  sunken toggle-button-group track. Normally set by the parent group. */
+    variant: 'connected' | 'track';
+    /** When set, the leading/trailing icon renders at this weight while the button
+     *  is selected (e.g. 'fill' for the active segment of a track toggle). */
+    selectedIconWeight?: 'regular' | 'fill';
     coToggle: EventEmitter<{
         value: string;
         selected: boolean;

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

@@ -8,10 +8,15 @@ export declare class CoToggleButtonGroup {
     direction: 'row' | 'column';
     /** Stretch the group to fill its container; each button shares the width equally. */
     fullWidth: boolean;
+    /** 'connected' (default) keeps the seamless dark-fill segmented control.
+     *  'track' turns the group into a sunken gray track carrying detached rounded
+     *  pills (white + shadow when selected) — e.g. an icon-only view toggle. */
+    variant: 'connected' | 'track';
     el: HTMLElement;
     coChange: EventEmitter<string | string[]>;
     private get selectedValues();
     syncChildren(): void;
+    syncVariant(): void;
     componentDidLoad(): void;
     handleToggle(e: CustomEvent<{
         value: string;

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

@@ -18,6 +18,10 @@ export declare class CoTooltip {
     flip: boolean;
     /** Maximum width before text wraps. */
     maxWidth: string;
+    /** Full-width wrapper (opt-in) so the tooltip can wrap a flex/grid child that
+     *  must fill its track — e.g. an ellipsised list/table cell — without the
+     *  inline-block wrapper shrink-wrapping it. Drives the `:host([block])` CSS. */
+    block: boolean;
     visible: boolean;
     actualPlacement: Placement;
     el: HTMLElement;
@@ -44,6 +48,14 @@ export declare class CoTooltip {
     private handleFocusOut;
     private handleKeyDown;
     private updatePosition;
+    /**
+     * Promote the tooltip panel to the browser top layer (Popover API) so an
+     * ancestor's filter / mask / overflow / transform can't clip or mis-anchor it
+     * — needed when the trigger lives inside another top-layer panel (co-popover).
+     * Mirrors co-popover. No-ops where unsupported (falls back to in-place fixed
+     * positioning + offset-ancestor compensation).
+     */
+    private promotePanel;
     private scheduleUpdate;
     private addScrollListeners;
     private cleanupListeners;

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

@@ -0,0 +1,203 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+type VideoLang = 'es' | 'en' | 'pt';
+/**
+ * A fully configurable video player component with custom controls.
+ *
+ * @slot - Default slot (unused, reserved for future captions/overlays)
+ */
+export declare class CoVideo {
+    /** Video source URL */
+    src: string;
+    /** Poster/thumbnail image URL */
+    poster: string;
+    /** MIME type hint */
+    type: string;
+    /** Preload behavior */
+    preload: 'none' | 'metadata' | 'auto';
+    /** Auto-start playback (requires muted for browser autoplay) */
+    autoplay: boolean;
+    /** Loop playback */
+    loop: boolean;
+    /** Muted state */
+    muted: boolean;
+    /** Initial volume (0-1) */
+    volume: number;
+    /** Current playback position in seconds (enables resume) */
+    currentTime: number;
+    /** Playback speed */
+    playbackRate: number;
+    /** Available playback speeds (JSON array string) */
+    playbackRates: string;
+    /** Master toggle for custom control bar */
+    controls: boolean;
+    /** Show play/pause button */
+    showPlay: boolean;
+    /** Show volume controls */
+    showVolume: boolean;
+    /** Show progress/seek bar */
+    showProgress: boolean;
+    /** Show time display */
+    showTime: boolean;
+    /** Show fullscreen button */
+    showFullscreen: boolean;
+    /** Show playback speed selector */
+    showSpeed: boolean;
+    /** Show Picture-in-Picture button */
+    showPip: boolean;
+    /** Show download button */
+    showDownload: boolean;
+    /** Enable download functionality */
+    allowDownload: boolean;
+    /** Container aspect ratio */
+    aspectRatio: '16:9' | '4:3' | '1:1' | '21:9' | 'auto';
+    /** Border radius */
+    rounded: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Auto-hide controls after inactivity */
+    controlsAutoHide: boolean;
+    /** Milliseconds before controls hide */
+    controlsAutoHideDelay: number;
+    /** Disabled state */
+    disabled: boolean;
+    /** Progress percentage (0-100) that triggers coThresholdReached. 0 = disabled */
+    watchThreshold: number;
+    /** Language for labels and aria attributes */
+    locale: VideoLang;
+    coPlay: EventEmitter<void>;
+    coPause: EventEmitter<void>;
+    coEnded: EventEmitter<void>;
+    coReady: EventEmitter<{
+        duration: number;
+    }>;
+    coError: EventEmitter<{
+        code: number;
+        message: string;
+    }>;
+    coTimeUpdate: EventEmitter<{
+        currentTime: number;
+        duration: number;
+        progressPercent: number;
+    }>;
+    coSeeked: EventEmitter<{
+        from: number;
+        to: number;
+    }>;
+    coVolumeChange: EventEmitter<{
+        volume: number;
+        muted: boolean;
+    }>;
+    coFullscreenChange: EventEmitter<{
+        fullscreen: boolean;
+    }>;
+    coPlaybackRateChange: EventEmitter<{
+        rate: number;
+    }>;
+    coPipChange: EventEmitter<{
+        pip: boolean;
+    }>;
+    coDownload: EventEmitter<{
+        src: string;
+    }>;
+    coThresholdReached: EventEmitter<{
+        threshold: number;
+        currentTime: number;
+        duration: number;
+    }>;
+    private isPlaying;
+    private internalCurrentTime;
+    private duration;
+    private buffered;
+    private volumeLevel;
+    private isMuted;
+    private isFullscreen;
+    private internalPlaybackRate;
+    private isLoading;
+    private showControlBar;
+    private hasError;
+    private errorMessage;
+    private showSpeedMenu;
+    private isPip;
+    private thresholdFired;
+    private hasStarted;
+    private isSeeking;
+    private showVolumeSlider;
+    el: HTMLElement;
+    private videoEl?;
+    private containerEl?;
+    private progressTrackEl?;
+    private volumeTrackEl?;
+    private controlsTimer?;
+    private lastTimeUpdateEmit;
+    private parsedRates;
+    private seekFromTime;
+    private externalTimeUpdate;
+    private get t();
+    private get progressPercent();
+    private get pipSupported();
+    onSrcChange(): void;
+    onMutedChange(): void;
+    onVolumeChange(): void;
+    onCurrentTimeChange(): void;
+    onPlaybackRateChange(): void;
+    onPlaybackRatesChange(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    togglePlay(): Promise<void>;
+    seek(time: number): Promise<void>;
+    setVolume(level: number): Promise<void>;
+    toggleMute(): Promise<void>;
+    toggleFullscreen(): Promise<void>;
+    togglePip(): Promise<void>;
+    private parseRates;
+    private resetState;
+    private bindVideoEvents;
+    private formatTime;
+    private resetControlsTimer;
+    private handleContainerMouseMove;
+    private handleContainerMouseLeave;
+    private handleContainerTouchStart;
+    private onLoadedMetadata;
+    private onPlay;
+    private onPause;
+    private onEnded;
+    private onTimeUpdate;
+    private onWaiting;
+    private onCanPlay;
+    private onError;
+    private onProgress;
+    private onNativeVolumeChange;
+    private onNativeRateChange;
+    private handlePlayClick;
+    private handleBigPlayClick;
+    private handleMuteClick;
+    private isDraggingVolume;
+    private handleVolumeMouseEnter;
+    private handleVolumeMouseLeave;
+    private handleProgressPointerDown;
+    private seekFromPointerEvent;
+    private handleVolumePointerDown;
+    private setVolumeFromPointerEvent;
+    private handleSpeedClick;
+    private handleSpeedSelect;
+    private handleFullscreenClick;
+    private handleFullscreenChange;
+    private handlePipClick;
+    private handleEnterPip;
+    private handleLeavePip;
+    private handleDownloadClick;
+    private handleRetryClick;
+    private handleKeyDown;
+    private handleVideoAreaClick;
+    private renderBigPlayButton;
+    private renderPoster;
+    private renderLoader;
+    private renderError;
+    private renderProgressBar;
+    private renderVolumeControl;
+    private renderSpeedMenu;
+    private renderControls;
+    render(): any;
+}
+export {};