@dskripchenko/ui 1.14.0 → 1.15.1

package/README.md

@@ -23,6 +23,7 @@ A Vue 3 component, token, and theme library on CSS custom properties.
 - **i18n** — built-in `ru` + `en` locales, `UidLocaleProvider` for partial overrides or custom locales
 - **~1500 icons** — `lucide-vue-next` under the hood + `@dskripchenko/ui/icons` sub-export
 - **Zero runtime chart deps** — built-in SVG primitives (Sparkline, ProgressRing, Gauge, Heatmap)
+- **Media players without dependencies** — video and audio on the native elements, in-browser waveform, HLS (fMP4 and MPEG-TS) in a lazily loaded entry
 
 ## Install
 
@@ -95,19 +96,21 @@ A short selection — the full catalog is in [Storybook](https://dskripchenko.gi
 
 **Charts:** Sparkline, ProgressRing, Gauge, Heatmap
 
+**Media:** Video, Audio (waveform, mini, playlist), HLS adapter (`@dskripchenko/ui/hls`)
+
 **Wizards:** Stepper, Wizard, WizardStep
 
 **Patterns:** Header, Footer, Sidebar, PageHeader, EmptyState, ErrorState, Result
 
 **Layouts:** SimpleLayout, SidebarLayout, AuthLayout, WizardLayout
 
-**Composables:** useTheme, useLocale, useField, useToast, useWizard, useSidebar, useCommandPalette, useFocusTrap, useScrollLock, usePopover
+**Composables:** useMediaController, useTheme, useLocale, useField, useToast, useWizard, useSidebar, useCommandPalette, useFocusTrap, useScrollLock, usePopover
 
 ## Documentation
 
 User docs are translated into four languages — pick yours:
 
-- 🇬🇧 **English** (default): [getting-started](./docs/en/getting-started.md), [theming](./docs/en/theming.md), [tokens](./docs/en/tokens.md), [icons](./docs/en/icons.md), [patterns](./docs/en/patterns.md), [validation](./docs/en/validation.md), [charts](./docs/en/charts.md), [markdown](./docs/en/markdown.md), [i18n](./docs/en/i18n.md)
+- 🇬🇧 **English** (default): [getting-started](./docs/en/getting-started.md), [theming](./docs/en/theming.md), [tokens](./docs/en/tokens.md), [icons](./docs/en/icons.md), [patterns](./docs/en/patterns.md), [validation](./docs/en/validation.md), [charts](./docs/en/charts.md), [markdown](./docs/en/markdown.md), [video](./docs/en/video.md), [audio](./docs/en/audio.md), [i18n](./docs/en/i18n.md)
 - 🇷🇺 **Русский**: [docs/ru/](./docs/ru/)
 - 🇩🇪 **Deutsch**: [docs/de/](./docs/de/)
 - 🇨🇳 **中文**: [docs/zh/](./docs/zh/)

package/dist/components/Audio/UidAudio.vue.d.ts

@@ -0,0 +1,127 @@
+import { UidMediaErrorInfo } from '../Media/useMediaController.js';
+import { HlsOptions } from '../../hls/index.js';
+import { UidHlsModule } from '../Video/UidVideo.vue';
+export interface UidAudioTrack {
+    src: string;
+    type?: string;
+    title?: string;
+    artist?: string;
+    /** Precomputed waveform peaks (0..1). */
+    peaks?: number[];
+    /** Known duration in seconds, shown in the playlist before metadata loads. */
+    duration?: number;
+}
+export interface UidAudioProps {
+    src?: string;
+    type?: string;
+    title?: string;
+    artist?: string;
+    /** Playlist: next / previous buttons, a track list and auto-advance. */
+    tracks?: UidAudioTrack[];
+    /** `mini` — a compact inline player for tables and lists. */
+    variant?: 'default' | 'mini';
+    /** Draws the waveform as the scrub bar, decoded in the browser. */
+    waveform?: boolean;
+    /** Precomputed peaks (0..1); implies the waveform without decoding. */
+    peaks?: number[];
+    /** Files larger than this are not decoded for the waveform (bytes). */
+    waveformMaxBytes?: number;
+    /** Audio longer than this is not decoded for the waveform (seconds). */
+    waveformMaxDuration?: number;
+    /** Plays the next playlist track when one ends. */
+    autoAdvance?: boolean;
+    /** Repeats the track, or the whole playlist. */
+    loop?: boolean;
+    preload?: 'none' | 'metadata' | 'auto';
+    crossorigin?: '' | 'anonymous' | 'use-credentials';
+    exclusive?: boolean;
+    resumeKey?: string;
+    rates?: number[];
+    hotkeys?: boolean;
+    showVolume?: boolean;
+    showRate?: boolean;
+    /** Shows the track list in playlist mode. */
+    showPlaylist?: boolean;
+    hlsOptions?: Omit<HlsOptions, 'onError'>;
+    /** Loads the HLS adapter for `.m3u8` sources; defaults to the lazily imported `@dskripchenko/ui/hls`. */
+    hlsLoader?: () => Promise<UidHlsModule>;
+}
+type __VLS_Props = UidAudioProps;
+declare function prev(): void;
+declare function next(): void;
+type __VLS_PublicProps = {
+    'index'?: number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    play: () => Promise<void>;
+    pause: () => void;
+    toggle: () => void;
+    seek: (time: number) => void;
+    next: typeof next;
+    prev: typeof prev;
+    state: {
+        playing: boolean;
+        paused: boolean;
+        ended: boolean;
+        waiting: boolean;
+        stalled: boolean;
+        seeking: boolean;
+        ready: boolean;
+        currentTime: number;
+        duration: number;
+        live: boolean;
+        buffered: [number, number][];
+        volume: number;
+        muted: boolean;
+        rate: number;
+        fullscreen: boolean;
+        pip: boolean;
+        error: {
+            kind: import('../Media').UidMediaErrorKind;
+            detail?: string | undefined;
+        } | null;
+    };
+    media: import('vue').Ref<HTMLAudioElement | null, HTMLAudioElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (error: UidMediaErrorInfo) => any;
+    play: () => any;
+    pause: () => any;
+    ended: () => any;
+    trackchange: (index: number) => any;
+    "update:index": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onError?: ((error: UidMediaErrorInfo) => any) | undefined;
+    onPlay?: (() => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onEnded?: (() => any) | undefined;
+    onTrackchange?: ((index: number) => any) | undefined;
+    "onUpdate:index"?: ((value: number) => any) | undefined;
+}>, {
+    type: string;
+    variant: "default" | "mini";
+    title: string;
+    src: string;
+    peaks: number[];
+    tracks: UidAudioTrack[];
+    loop: boolean;
+    preload: "none" | "metadata" | "auto";
+    crossorigin: "" | "anonymous" | "use-credentials";
+    exclusive: boolean;
+    resumeKey: string;
+    rates: number[];
+    hotkeys: boolean;
+    hlsOptions: Omit<HlsOptions, "onError">;
+    hlsLoader: () => Promise<UidHlsModule>;
+    artist: string;
+    waveform: boolean;
+    waveformMaxBytes: number;
+    waveformMaxDuration: number;
+    autoAdvance: boolean;
+    showVolume: boolean;
+    showRate: boolean;
+    showPlaylist: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+    audio: HTMLAudioElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/Audio/index.d.ts

@@ -0,0 +1,2 @@
+export { default as UidAudio } from './UidAudio.vue';
+export type { UidAudioProps, UidAudioTrack } from './UidAudio.vue';

package/dist/components/Gauge/UidGauge.vue.d.ts

@@ -26,9 +26,9 @@ export interface UidGaugeProps {
 declare const _default: import('vue').DefineComponent<UidGaugeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidGaugeProps> & Readonly<{}>, {
     size: number;
     strokeWidth: number;
+    value: number;
     min: number;
     max: number;
-    value: number;
     locale: string;
     showValue: boolean;
     precision: number;

package/dist/components/Grid/UidGrid.vue.d.ts

@@ -21,9 +21,9 @@ type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<UidGridProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidGridProps> & Readonly<{}>, {
     as: string;
     justify: "start" | "center" | "end" | "stretch";
+    align: "start" | "center" | "end" | "stretch";
     gap: string;
     cols: number | string;
-    align: "start" | "center" | "end" | "stretch";
     rowGap: string;
     colGap: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/components/Media/UidMediaMenu.vue.d.ts

@@ -0,0 +1,65 @@
+export interface UidMediaMenuOption {
+    value: string | number;
+    label: string;
+    hint?: string;
+    /** Shorter label for the compact sheet (`1×` instead of `Normal`). */
+    short?: string;
+}
+export interface UidMediaMenuGroup {
+    id: string;
+    /** `action` — plain commands (no checked state), e.g. picture-in-picture folded into the menu. */
+    kind?: 'radio' | 'action';
+    label?: string;
+    value: string | number | null;
+    options: UidMediaMenuOption[];
+}
+type __VLS_Props = {
+    label: string;
+    groups: UidMediaMenuGroup[];
+    align?: 'start' | 'end';
+    buttonClass?: string;
+    closeLabel?: string;
+};
+declare function show(focus?: 'checked' | 'first' | 'last'): Promise<void>;
+declare function hide(returnFocus?: boolean): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): unknown;
+    }> & {
+        default(): unknown;
+    };
+    refs: {
+        root: HTMLDivElement;
+        button: HTMLButtonElement;
+        panel: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    show: typeof show;
+    hide: typeof hide;
+    open: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (group: string, value: string | number) => any;
+    "update:open": (open: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((group: string, value: string | number) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+    align: "start" | "end";
+    buttonClass: string;
+    closeLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+    button: HTMLButtonElement;
+    panel: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Media/UidMediaScrubber.vue.d.ts

@@ -0,0 +1,38 @@
+import { UidMediaCue, UidMediaRange, UidMediaThumbnail } from './mediaUtils.js';
+type __VLS_Props = {
+    currentTime: number;
+    duration: number;
+    buffered?: UidMediaRange[];
+    chapters?: UidMediaCue[];
+    peaks?: number[] | null;
+    thumbnailAt?: (time: number) => UidMediaThumbnail | null;
+    label: string;
+    valueText: (current: string, total: string) => string;
+    disabled?: boolean;
+    step?: number;
+    /** A waveform is on its way: show a placeholder instead of a bar that looks final. */
+    pending?: boolean;
+    /** Hides the hover preview (e.g. while a menu is open over the bar). */
+    suppressPreview?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    seek: (time: number) => any;
+    scrubstart: () => any;
+    scrubend: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSeek?: ((time: number) => any) | undefined;
+    onScrubstart?: (() => any) | undefined;
+    onScrubend?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    step: number;
+    pending: boolean;
+    chapters: UidMediaCue[];
+    buffered: UidMediaRange[];
+    peaks: number[] | null;
+    thumbnailAt: (time: number) => UidMediaThumbnail | null;
+    suppressPreview: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/Media/index.d.ts

@@ -0,0 +1,6 @@
+export { useMediaController } from './useMediaController.js';
+export type { UseMediaControllerOptions, UidMediaController, UidMediaState, UidMediaErrorInfo, UidMediaErrorKind, } from './useMediaController.js';
+export { formatTime, parseVtt, cueText, cueAt, parseThumbnail, isHlsSource, orderSources, PLAYBACK_RATES, } from './mediaUtils.js';
+export type { UidMediaSource, UidMediaTrack, UidMediaCue, UidMediaRange, UidMediaThumbnail, } from './mediaUtils.js';
+export { computePeaks, resamplePeaks, normalizePeaks, peaksToPath, getWaveform, clearWaveformCache } from './waveform.js';
+export type { ComputePeaksOptions, WaveformOptions } from './waveform.js';

package/dist/components/Media/mediaUtils.d.ts

@@ -0,0 +1,47 @@
+export interface UidMediaSource {
+    src: string;
+    /** MIME type, e.g. `video/mp4`, `video/webm; codecs="vp9,opus"`, `application/x-mpegURL`. */
+    type?: string;
+    /** Quality label shown in the quality menu (`1080p`, `720p`…). */
+    label?: string;
+}
+export interface UidMediaTrack {
+    src: string;
+    kind?: 'subtitles' | 'captions' | 'chapters';
+    srclang?: string;
+    label?: string;
+    default?: boolean;
+}
+export interface UidMediaCue {
+    start: number;
+    end: number;
+    text: string;
+}
+export type UidMediaRange = [number, number];
+export declare function formatTime(value: number, withHours?: boolean): string;
+export declare function toRanges(ranges: TimeRanges | null | undefined): UidMediaRange[];
+/** End of the buffered range that contains `time` (with a small gap tolerance), or `time` itself. */
+export declare function bufferedEndAt(ranges: UidMediaRange[], time: number, gap?: number): number;
+export declare function isHlsSource(source: UidMediaSource): boolean;
+/**
+ * Candidates in the order the browser should try them: the ones `canPlay` vouches for first,
+ * HLS sources count as playable when `hlsPlayable` says so (native or MSE).
+ */
+export declare function orderSources(sources: UidMediaSource[], canPlay: (type: string) => string, hlsPlayable: boolean): UidMediaSource[];
+/** Minimal WebVTT parser: cue timings and text (settings, styles and regions are ignored). */
+export declare function parseVtt(text: string): UidMediaCue[];
+/** Plain text of a cue: VTT tags (`<v Bob>`, `<i>`, timestamps) dropped, entities decoded. */
+export declare function cueText(raw: string): string;
+export declare function cueAt(cues: UidMediaCue[], time: number): UidMediaCue | undefined;
+export interface UidMediaThumbnail {
+    url: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** A thumbnails-VTT cue body: `sprite.jpg#xywh=0,0,160,90` (or a whole image), resolved against `base`. */
+export declare function parseThumbnail(text: string, base: string): UidMediaThumbnail | null;
+export declare function resolveUrl(path: string, base: string): string;
+export declare const PLAYBACK_RATES: number[];
+export declare function clamp(v: number, min: number, max: number): number;

package/dist/components/Media/useMediaController.d.ts

@@ -0,0 +1,80 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { UidMediaRange } from './mediaUtils.js';
+export type UidMediaErrorKind = 'aborted' | 'network' | 'decode' | 'unsupported' | 'mse' | 'manifest' | 'encrypted' | 'codec' | 'unknown';
+export interface UidMediaErrorInfo {
+    kind: UidMediaErrorKind;
+    /** Technical detail (browser message, HTTP status) — not localised. */
+    detail?: string;
+}
+export interface UseMediaControllerOptions {
+    /** Starting this player pauses other exclusive players on the page (default `true`). */
+    exclusive?: MaybeRefOrGetter<boolean>;
+    /** Element that goes full screen; defaults to the media element. */
+    fullscreenTarget?: Ref<HTMLElement | null>;
+    /** localStorage key to remember the playback position under. */
+    resumeKey?: MaybeRefOrGetter<string | undefined>;
+    /** Seconds a hotkey arrow moves (default 5); j/l move twice as far. */
+    seekStep?: number;
+    onCaptionsToggle?: () => void;
+}
+export interface UidMediaState {
+    playing: boolean;
+    paused: boolean;
+    ended: boolean;
+    waiting: boolean;
+    stalled: boolean;
+    seeking: boolean;
+    ready: boolean;
+    currentTime: number;
+    duration: number;
+    live: boolean;
+    buffered: UidMediaRange[];
+    volume: number;
+    muted: boolean;
+    rate: number;
+    fullscreen: boolean;
+    pip: boolean;
+    error: UidMediaErrorInfo | null;
+}
+export declare function useMediaController(media: Ref<HTMLMediaElement | null>, options?: UseMediaControllerOptions): {
+    state: {
+        playing: boolean;
+        paused: boolean;
+        ended: boolean;
+        waiting: boolean;
+        stalled: boolean;
+        seeking: boolean;
+        ready: boolean;
+        currentTime: number;
+        duration: number;
+        live: boolean;
+        buffered: [number, number][];
+        volume: number;
+        muted: boolean;
+        rate: number;
+        fullscreen: boolean;
+        pip: boolean;
+        error: {
+            kind: UidMediaErrorKind;
+            detail?: string | undefined;
+        } | null;
+    };
+    bufferedEnd: import('vue').ComputedRef<number>;
+    canFullscreen: import('vue').ComputedRef<boolean>;
+    canPip: import('vue').ComputedRef<boolean>;
+    play: () => Promise<void>;
+    pause: () => void;
+    toggle: () => void;
+    seek: (time: number) => void;
+    skip: (delta: number) => void;
+    setVolume: (v: number) => void;
+    changeVolume: (delta: number) => void;
+    setMuted: (value: boolean) => void;
+    toggleMute: () => void;
+    setRate: (rate: number) => void;
+    toggleFullscreen: () => Promise<void>;
+    togglePip: () => Promise<void>;
+    setError: (error: UidMediaErrorInfo | null) => void;
+    handleKey: (e: KeyboardEvent) => boolean;
+};
+export type UidMediaController = ReturnType<typeof useMediaController>;

package/dist/components/Media/useMediaLocale.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef } from 'vue';
+import { UidMediaLocale } from '../../locales/types.js';
+export declare function useMediaLocale(): ComputedRef<UidMediaLocale>;

package/dist/components/Media/waveform.d.ts

@@ -0,0 +1,27 @@
+export interface ComputePeaksOptions {
+    /** Samples processed between yields to the event loop. */
+    chunkSize?: number;
+    /** Yields between chunks; defaults to requestIdleCallback / setTimeout. */
+    yieldFn?: () => Promise<void>;
+    signal?: AbortSignal;
+}
+export interface WaveformOptions {
+    /** Number of peaks to compute (default 1024). */
+    count?: number;
+    /** Skip files larger than this many bytes (default 40 MB). */
+    maxBytes?: number;
+    /** Skip audio longer than this many seconds (default 30 min). */
+    maxDuration?: number;
+    fetchInit?: RequestInit;
+}
+export declare function idleYield(): Promise<void>;
+/** Max absolute amplitude per bucket across all channels, normalised to 0..1, processed in chunks. */
+export declare function computePeaks(channels: ArrayLike<number>[], count: number, options?: ComputePeaksOptions): Promise<number[]>;
+export declare function normalizePeaks(peaks: number[]): number[];
+/** Reduces (max) or stretches (nearest) peaks to `n` bars for drawing. */
+export declare function resamplePeaks(peaks: number[], n: number): number[];
+/** SVG path of centred bars (viewBox `0 0 n*step 100`), heights clamped to a visible minimum. */
+export declare function peaksToPath(peaks: number[], step?: number, bar?: number, minHeight?: number): string;
+/** Peaks of an audio file decoded in the browser; `null` when skipped or impossible. Cached per src. */
+export declare function getWaveform(src: string, options?: WaveformOptions): Promise<number[] | null>;
+export declare function clearWaveformCache(): void;

package/dist/components/Menu/UidMenu.vue.d.ts

@@ -1,10 +1,16 @@
+declare function close(): void;
+declare function toggle(): Promise<void>;
+declare function openAt(x: number, y: number): void;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+};
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
-        trigger(): unknown;
+        trigger?(): unknown;
         default(): unknown;
     }> & {
-        trigger(): unknown;
+        trigger?(): unknown;
         default(): unknown;
     };
     refs: {
@@ -14,7 +20,15 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    openAt: typeof openAt;
+    close: typeof close;
+    toggle: typeof toggle;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     triggerRef: HTMLDivElement;
     menuRef: HTMLDivElement;
 }, any>;

package/dist/components/Pagination/UidPaginationCursor.vue.d.ts

@@ -5,11 +5,11 @@ export interface UidPaginationCursorProps {
     nextLabel?: string;
 }
 declare const _default: import('vue').DefineComponent<UidPaginationCursorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    prev: () => any;
     next: () => any;
+    prev: () => any;
 }, string, import('vue').PublicProps, Readonly<UidPaginationCursorProps> & Readonly<{
-    onPrev?: (() => any) | undefined;
     onNext?: (() => any) | undefined;
+    onPrev?: (() => any) | undefined;
 }>, {
     hasPrev: boolean;
     hasNext: boolean;

package/dist/components/Progress/UidProgress.vue.d.ts

@@ -12,8 +12,8 @@ declare const _default: import('vue').DefineComponent<UidProgressProps, {}, {},
     size: "sm" | "md" | "lg";
     label: string;
     variant: UidProgressVariant;
-    max: number;
     value: number;
+    max: number;
     showValue: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/components/ProgressRing/UidProgressRing.vue.d.ts

@@ -25,8 +25,8 @@ type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<UidProgressRingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidProgressRingProps> & Readonly<{}>, {
     size: number;
     strokeWidth: number;
-    max: number;
     value: number;
+    max: number;
     indeterminate: boolean;
     tone: RingTone;
     showLabel: boolean;

package/dist/components/Stack/UidStack.vue.d.ts

@@ -24,8 +24,8 @@ declare const __VLS_component: import('vue').DefineComponent<UidStackProps, {},
     as: string;
     wrap: boolean;
     justify: "start" | "center" | "end" | "between" | "around" | "evenly";
-    gap: string;
     align: "start" | "center" | "end" | "stretch" | "baseline";
+    gap: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Video/UidVideo.vue.d.ts

@@ -0,0 +1,106 @@
+import { UidMediaErrorInfo } from '../Media/useMediaController.js';
+import { UidMediaSource, UidMediaTrack } from '../Media/mediaUtils.js';
+import { HlsOptions } from '../../hls/index.js';
+export type UidHlsModule = typeof import('../../hls/index.js');
+export interface UidVideoProps {
+    src?: string;
+    /** Alternatives in order of preference; labelled ones form the quality menu. */
+    sources?: UidMediaSource[];
+    poster?: string;
+    /** WebVTT subtitles, captions and chapters. */
+    tracks?: UidMediaTrack[];
+    /** WebVTT with sprite thumbnails (`sprite.jpg#xywh=x,y,w,h`) shown over the scrub bar. */
+    thumbnails?: string;
+    /** Starts playing muted as soon as possible (browsers block unmuted autoplay). */
+    autoplay?: boolean;
+    muted?: boolean;
+    loop?: boolean;
+    preload?: 'none' | 'metadata' | 'auto';
+    /** `false` hides the kit's controls (the element stays bare). */
+    controls?: boolean;
+    crossorigin?: '' | 'anonymous' | 'use-credentials';
+    /** Starting this player pauses the other exclusive players on the page. */
+    exclusive?: boolean;
+    /** Remembers the position in localStorage under this key and resumes from it. */
+    resumeKey?: string;
+    rates?: number[];
+    hotkeys?: boolean;
+    /** Box ratio before the video size is known, e.g. `16 / 9`. */
+    aspectRatio?: string;
+    /** Accessible name of the player. */
+    title?: string;
+    /** Milliseconds of inactivity before the controls hide while playing. */
+    autoHide?: number;
+    hlsOptions?: Omit<HlsOptions, 'onLevels' | 'onLevelSwitched' | 'onAudioTracks' | 'onAudioTrackSwitched' | 'onError'>;
+    /** Loads the HLS adapter; defaults to the lazily imported `@dskripchenko/ui/hls`. */
+    hlsLoader?: () => Promise<UidHlsModule>;
+}
+declare const _default: import('vue').DefineComponent<UidVideoProps, {
+    play: () => Promise<void>;
+    pause: () => void;
+    toggle: () => void;
+    seek: (time: number) => void;
+    state: {
+        playing: boolean;
+        paused: boolean;
+        ended: boolean;
+        waiting: boolean;
+        stalled: boolean;
+        seeking: boolean;
+        ready: boolean;
+        currentTime: number;
+        duration: number;
+        live: boolean;
+        buffered: [number, number][];
+        volume: number;
+        muted: boolean;
+        rate: number;
+        fullscreen: boolean;
+        pip: boolean;
+        error: {
+            kind: import('../Media').UidMediaErrorKind;
+            detail?: string | undefined;
+        } | null;
+    };
+    media: import('vue').Ref<HTMLVideoElement | null, HTMLVideoElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (error: UidMediaErrorInfo) => any;
+    play: () => any;
+    pause: () => any;
+    ended: () => any;
+    qualitychange: (label: string) => any;
+    audiotrackchange: (label: string) => any;
+}, string, import('vue').PublicProps, Readonly<UidVideoProps> & Readonly<{
+    onError?: ((error: UidMediaErrorInfo) => any) | undefined;
+    onPlay?: (() => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onEnded?: (() => any) | undefined;
+    onQualitychange?: ((label: string) => any) | undefined;
+    onAudiotrackchange?: ((label: string) => any) | undefined;
+}>, {
+    title: string;
+    src: string;
+    controls: boolean;
+    muted: boolean;
+    sources: UidMediaSource[];
+    poster: string;
+    tracks: UidMediaTrack[];
+    thumbnails: string;
+    autoplay: boolean;
+    loop: boolean;
+    preload: "none" | "metadata" | "auto";
+    crossorigin: "" | "anonymous" | "use-credentials";
+    exclusive: boolean;
+    resumeKey: string;
+    rates: number[];
+    hotkeys: boolean;
+    aspectRatio: string;
+    autoHide: number;
+    hlsOptions: Omit<HlsOptions, "onLevels" | "onLevelSwitched" | "onAudioTracks" | "onAudioTrackSwitched" | "onError">;
+    hlsLoader: () => Promise<UidHlsModule>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+    video: HTMLVideoElement;
+    trackEls: HTMLTrackElement[];
+}, HTMLDivElement>;
+export default _default;

package/dist/components/Video/index.d.ts

@@ -0,0 +1,2 @@
+export { default as UidVideo } from './UidVideo.vue';
+export type { UidVideoProps, UidHlsModule } from './UidVideo.vue';

package/dist/composables/useLocale.d.ts

@@ -1,4 +1,5 @@
-import { ComputedRef } from 'vue';
+import { ComputedRef, InjectionKey } from 'vue';
 import { UidLocale, UidPartialLocale } from '../locales/types.js';
+export declare const localeKey: InjectionKey<ComputedRef<UidLocale>>;
 export declare function provideLocale(source: ComputedRef<UidLocale | UidPartialLocale | undefined>): void;
 export declare function useLocale(): ComputedRef<UidLocale>;