@codingfactory/mediables-vue 2.0.1

package/dist/types/video.d.ts

@@ -0,0 +1,449 @@
+/**
+ * Video Subsystem Type Definitions
+ * Provides comprehensive typing for video editing, playback, and export
+ */
+/**
+ * Core video media type extending base media
+ */
+export interface VideoMedia {
+    uuid: string;
+    filename: string;
+    /** Optional playback URL for editor/runtime (non-persisted helper) */
+    url?: string;
+    /** Optional local file reference for in-memory editing (non-persisted helper) */
+    file?: File;
+    mime_type: string;
+    size: number;
+    duration: number;
+    width: number;
+    height: number;
+    aspect_ratio: string;
+    frame_rate: number;
+    bitrate?: number;
+    has_audio: boolean;
+    has_captions?: boolean;
+    thumbnail_url?: string;
+    thumbnail_time?: number;
+    poster_url?: string;
+    playback_url?: string;
+    token_expires_at?: string;
+    provider: 'local' | 'bunny' | 'cloudflare';
+    provider_asset_id?: string;
+    playback_id?: string;
+    processing_status: 'pending' | 'processing' | 'ready' | 'failed';
+    processing_progress: number;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Timeline clip representation
+ */
+export interface TimelineClip {
+    id: string;
+    type: 'clip' | 'video';
+    timelineStart: number;
+    timelineEnd: number;
+    startTime?: number;
+    endTime?: number;
+    track?: number;
+    sourceIn: number;
+    sourceOut: number;
+    /**
+     * Immutable source-domain bounds for this clip.
+     * - sourceMinIn: earliest allowed sourceIn (usually 0)
+     * - sourceMaxOut: latest allowed sourceOut (usually full media duration)
+     * Used to clamp trims independently of current timeline length.
+     */
+    sourceMinIn?: number;
+    sourceMaxOut?: number;
+    speed?: number;
+    filters?: AppliedFilter[];
+    thumbnail?: string;
+    label?: string;
+    url?: string;
+    muted?: boolean;
+    scale?: number;
+    duration?: number;
+    transform?: {
+        x?: number;
+        y?: number;
+        rotation?: number;
+        opacity?: number;
+        scale?: number;
+    };
+}
+/**
+ * Filter definition for video processing
+ */
+export interface VideoFilterDefinition {
+    id: string;
+    name: string;
+    category: 'color' | 'blur' | 'stylize' | 'effects' | 'transform';
+    ffmpeg?: string;
+    pixiFilter?: string;
+    defaultParams?: Record<string, any>;
+    paramRanges?: Record<string, {
+        min: number;
+        max: number;
+        step: number;
+    }>;
+}
+/**
+ * Applied filter with parameters
+ */
+export interface AppliedFilter {
+    id: string;
+    filterId: string;
+    params: Record<string, any>;
+    intensity: number;
+    ffmpegCommand?: string;
+}
+/**
+ * Text overlay entry persisted in recipe
+ */
+export interface TextOverlayRecipe {
+    id?: string;
+    content: string;
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: string;
+    color?: string;
+    position?: 'center' | 'top' | 'bottom' | 'left' | 'right' | {
+        x: number | string;
+        y: number | string;
+    };
+    startTime?: number;
+    duration?: number;
+    animation?: {
+        type: 'fade-in' | 'fade-out' | 'rotate' | 'scale' | 'slide' | 'typewriter' | 'custom';
+        duration?: number;
+        easing?: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
+        rotation?: {
+            from: number;
+            to: number;
+        };
+        scale?: {
+            from: number;
+            to: number;
+        };
+        translate?: {
+            fromX: number;
+            toX: number;
+            fromY: number;
+            toY: number;
+        };
+    };
+    textAlign?: 'left' | 'center' | 'right';
+    textBaseline?: 'top' | 'middle' | 'bottom';
+}
+/**
+ * Audio track entry persisted in recipe (URL-based only)
+ */
+export interface AudioTrackRecipe {
+    id?: string;
+    source: string;
+    volume?: number;
+    startTime?: number;
+    duration?: number;
+    fadeIn?: number;
+    fadeOut?: number;
+    loop?: boolean;
+    name?: string;
+}
+/**
+ * Audio settings for export
+ */
+export interface AudioSettings {
+    volume: number;
+    fadeIn?: number;
+    fadeOut?: number;
+    muted?: boolean;
+}
+/**
+ * Output/export settings
+ */
+export interface OutputSettings {
+    format: 'mp4' | 'webm' | 'mov';
+    codec: 'h264' | 'h265' | 'vp9';
+    quality: '360p' | '480p' | '720p' | '1080p' | '1440p' | '2160p';
+    fps: number;
+    bitrate?: number;
+}
+/**
+ * Metadata attached to a locally rendered WebGL/PIXI export payload.
+ */
+export interface WebGLExportMeta {
+    duration?: number;
+    width?: number;
+    height?: number;
+    format?: string;
+    sizeBytes?: number;
+    size_bytes?: number;
+}
+/**
+ * Rendered export payload used by host apps to upload processed video outputs.
+ */
+export interface WebGLExportPayload {
+    file: File;
+    recipe: VideoRecipe;
+    meta?: WebGLExportMeta;
+}
+/**
+ * Complete video export recipe
+ */
+export interface VideoRecipe {
+    version: '1.0';
+    duration?: number;
+    source: {
+        media_uuid: string;
+        duration: number;
+        original_width: number;
+        original_height: number;
+    };
+    timeline: TimelineClip[];
+    filters: AppliedFilter[];
+    audio: AudioSettings;
+    textOverlays?: TextOverlayRecipe[];
+    audioTracks?: AudioTrackRecipe[];
+    output: OutputSettings;
+    /** PIXI-rendered poster frame as a data URL (transient — not persisted to backend) */
+    posterFrame?: string;
+    metadata?: {
+        source_url?: string;
+        title?: string;
+        description?: string;
+        created_at: string;
+        editor_version: string;
+    };
+}
+/**
+ * Video editor state
+ */
+export interface VideoEditorState {
+    mediaUuid: string;
+    media?: VideoMedia;
+    clips: TimelineClip[];
+    playheadPosition: number;
+    totalDuration: number;
+    originalDuration: number;
+    filters: AppliedFilter[];
+    activeFilterId?: string;
+    textOverlays?: TextOverlayRecipe[];
+    audioTracks?: AudioTrackRecipe[];
+    audioVolume: number;
+    audioFadeIn: number;
+    audioFadeOut: number;
+    exportQuality: OutputSettings['quality'];
+    exportFormat: OutputSettings['format'];
+    hasChanges: boolean;
+    isPlaying: boolean;
+    selectedClipId?: string;
+    zoomLevel: number;
+}
+/**
+ * Export job status
+ */
+export interface ExportJob {
+    id: string;
+    media_uuid: string;
+    recipe: VideoRecipe;
+    status: 'pending' | 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    progress: number;
+    output_url?: string;
+    error?: string;
+    error_message?: string;
+    started_at?: string;
+    completed_at?: string;
+    meta?: {
+        is_cancelled?: boolean;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Live stream configuration
+ */
+export interface LiveStreamConfig {
+    low_latency: boolean;
+    auto_record: boolean;
+    max_duration?: number;
+    allowed_origins?: string[];
+}
+/**
+ * Live stream instance
+ */
+export interface LiveStream {
+    id: string;
+    media_uuid: string;
+    stream_key: string;
+    rtmp_url: string;
+    playback_url?: string;
+    status: 'idle' | 'starting' | 'live' | 'stopping' | 'ended' | 'error';
+    started_at?: string;
+    ended_at?: string;
+    viewer_count: number;
+    peak_viewers: number;
+    auto_record: boolean;
+    low_latency: boolean;
+    vod_media_uuid?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Live stream creation options
+ */
+export interface LiveStreamOptions {
+    title?: string;
+    low_latency?: boolean;
+    auto_record?: boolean;
+    reconnect_window?: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Live stream statistics
+ */
+export interface LiveStreamStats {
+    status: LiveStream['status'];
+    viewer_count: number;
+    peak_viewers: number;
+    duration?: number;
+    started_at?: string;
+    ended_at?: string;
+    has_vod?: boolean;
+}
+/**
+ * Upload response from backend
+ */
+export interface VideoUploadResponse {
+    upload_url: string;
+    upload_id: string;
+    media_uuid: string;
+    expires_at: string;
+    method?: string;
+    headers?: Record<string, string>;
+    max_size?: number | null;
+    resumable?: boolean;
+}
+/**
+ * Playback response with signed URL
+ */
+export interface PlaybackResponse {
+    playback_url: string;
+    token_expires_at: string;
+    thumbnail_url?: string;
+    poster_url?: string;
+}
+/**
+ * Frame extraction options
+ */
+export interface FrameExtractionOptions {
+    time: number;
+    format?: 'jpeg' | 'png' | 'webp';
+    quality?: number;
+    width?: number;
+    height?: number;
+}
+/**
+ * Video player options
+ */
+export interface VideoPlayerOptions {
+    media?: VideoMedia;
+    playbackUrl?: string;
+    isLive?: boolean;
+    controls?: boolean;
+    autoplay?: boolean;
+    muted?: boolean;
+    loop?: boolean;
+    preload?: 'none' | 'metadata' | 'auto';
+    crossorigin?: 'anonymous' | 'use-credentials';
+}
+/**
+ * Timeline interaction events
+ */
+export interface TimelineEvent {
+    type: 'trim' | 'split' | 'move' | 'delete';
+    clipId?: string;
+    position?: number;
+    edge?: 'start' | 'end';
+    delta?: number;
+}
+/**
+ * Filter preset
+ */
+export interface FilterPreset {
+    id: string;
+    name: string;
+    description?: string;
+    thumbnail?: string;
+    filters: AppliedFilter[];
+    category?: string;
+}
+/**
+ * Export preset for video export
+ */
+export interface ExportPreset {
+    id: string;
+    name: string;
+    description?: string;
+    format: 'mp4' | 'webm' | 'mov';
+    quality: 'low' | 'medium' | 'high' | 'max';
+    width: number;
+    height: number;
+    fps: number;
+    resolution?: {
+        width: number;
+        height: number;
+    };
+    framerate?: number;
+    bitrate?: number;
+}
+/**
+ * Touch gesture event
+ */
+export interface TouchGestureEvent {
+    type: 'pinch' | 'swipe' | 'tap' | 'long-press';
+    scale?: number;
+    direction?: 'left' | 'right' | 'up' | 'down';
+    position?: {
+        x: number;
+        y: number;
+    };
+    velocity?: number;
+}
+/**
+ * Video upload progress tracking
+ */
+export interface VideoUploadProgress {
+    id: string;
+    file: File;
+    filename: string;
+    progress: number;
+    status: 'pending' | 'uploading' | 'processing' | 'completed' | 'error' | 'cancelled';
+    error?: string;
+    mediaUuid?: string;
+    media?: VideoMedia;
+    bytesTotal: number;
+    bytesUploaded: number;
+    startedAt: Date;
+    completedAt?: Date;
+    uploadSpeed?: number;
+    timeRemaining?: number;
+}
+/**
+ * Video upload options for API requests
+ */
+export interface VideoUploadOptions {
+    collection: string;
+    filename: string;
+    size: number;
+    mime_type: string;
+    ownerUuid?: string;
+    ownerType?: string;
+}
+/**
+ * Quality level for adaptive streaming
+ */
+export interface QualityLevel {
+    label: string;
+    resolution: string;
+    bitrate: number;
+    height: number;
+}

package/dist/utils/category-tree-constants.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Category Tree Constants
+ *
+ * Default values and CSS class names for the hierarchical category tree system.
+ */
+/**
+ * Default values and constants
+ */
+export declare const CATEGORY_TREE_DEFAULTS: {
+    readonly maxDepth: 10;
+    readonly multiSelect: true;
+    readonly showProductCounts: true;
+    readonly searchable: true;
+    readonly includeEmpty: false;
+    readonly sortByName: true;
+    readonly expandAll: false;
+};
+/**
+ * CSS class names for consistent styling
+ */
+export declare const CATEGORY_TREE_CLASSES: {
+    readonly container: "category-tree-container";
+    readonly node: "category-tree-node";
+    readonly item: "category-tree-item";
+    readonly checkbox: "category-checkbox";
+    readonly label: "category-label";
+    readonly expandButton: "category-expand-button";
+    readonly expandIcon: "category-expand-icon";
+    readonly children: "category-children";
+    readonly count: "category-count";
+    readonly loading: "category-tree-loading";
+    readonly empty: "category-tree-empty";
+    readonly search: "category-tree-search";
+};
+export type CategoryTreeDefaults = typeof CATEGORY_TREE_DEFAULTS;
+export type CategoryTreeClasses = typeof CATEGORY_TREE_CLASSES;
+/**
+ * Type guards for runtime type checking
+ */
+import type { HierarchicalCategory, CategoryTreeNode } from '../types/types/category-hierarchy';
+export declare const isHierarchicalCategory: (obj: any) => obj is HierarchicalCategory;
+export declare const isCategoryTreeNode: (obj: any) => obj is CategoryTreeNode;

package/dist/utils/cookies.d.ts

@@ -0,0 +1,3 @@
+export declare function getCookie(name: string): string | null;
+export declare function setCookie(name: string, value: string, days?: number, path?: string): void;
+export declare function deleteCookie(name: string, path?: string): void;

package/dist/utils/crypto-polyfill.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Polyfill for crypto.randomUUID for browsers that don't support it
+ */
+export declare function polyfillCryptoRandomUUID(): void;

package/dist/utils/datetime.d.ts

@@ -0,0 +1,43 @@
+import { formatDate, formatDateTime } from './formatters';
+/**
+ * Composable for date formatting utilities
+ */
+export declare function useDateTime(): {
+    formatDate: typeof formatDate;
+    formatRelativeTime: typeof formatRelativeTime;
+    formatTime: typeof formatTime;
+    formatDateOnly: typeof formatDateOnly;
+    isFutureDate: typeof isFutureDate;
+    isPastDate: typeof isPastDate;
+    isToday: typeof isToday;
+    formatDuration: typeof formatDuration;
+    formatDateTime: typeof formatDateTime;
+};
+/**
+ * Format a date string or Date object into a relative time string (e.g., "2 hours ago")
+ */
+export declare function formatRelativeTime(date: string | Date): string;
+/**
+ * Format a date string or Date object into a time string (e.g., "14:30")
+ */
+export declare function formatTime(date: string | Date): string;
+/**
+ * Format a date string or Date object into a date-only string (e.g., "Jan 15, 2024")
+ */
+export declare function formatDateOnly(date: string | Date): string;
+/**
+ * Check if a date is in the future
+ */
+export declare function isFutureDate(date: string | Date): boolean;
+/**
+ * Check if a date is in the past
+ */
+export declare function isPastDate(date: string | Date): boolean;
+/**
+ * Check if a date is today
+ */
+export declare function isToday(date: string | Date): boolean;
+/**
+ * Format a duration in milliseconds into a human-readable string
+ */
+export declare function formatDuration(ms: number): string;

package/dist/utils/debounce.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a debounced function that delays invoking the provided function
+ * until after the specified wait time has elapsed since the last time it was invoked.
+ *
+ * @param fn The function to debounce
+ * @param wait The number of milliseconds to delay
+ * @param immediate Whether to invoke the function on the leading edge of the timeout
+ * @returns A debounced version of the function
+ */
+export declare function debounce<T extends (...args: any[]) => unknown>(fn: T, wait?: number, immediate?: boolean): (...args: Parameters<T>) => void;

package/dist/utils/debugConsole.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Debug Console Utilities
+ *
+ * Types and utilities for the Vue Debug Console system
+ */
+/**
+ * Network request captured by the debug console
+ */
+export interface NetworkRequest {
+    id: string;
+    method: string;
+    url: string;
+    status?: number;
+    statusText?: string;
+    type: string;
+    duration?: number;
+    timestamp: number;
+    requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    requestBody?: string | FormData | Record<string, unknown>;
+    responseBody?: string | Record<string, unknown>;
+    error?: string;
+    expanded?: boolean;
+    count?: number;
+    timestamps?: number[];
+    durations?: number[];
+    isGrouped?: boolean;
+}
+/**
+ * Console log entry captured by the debug console
+ */
+export interface ConsoleEntry {
+    id: string;
+    type: 'log' | 'error' | 'warn' | 'info' | 'debug';
+    message: string;
+    timestamp: number;
+    stack?: string;
+    args?: unknown[];
+    count?: number;
+}
+/**
+ * Debug console state
+ */
+export interface DebugConsoleState {
+    isOpen: boolean;
+    activeTab: 'console' | 'network' | 'storage' | 'vue';
+    consoleLogs: ConsoleEntry[];
+    networkRequests: NetworkRequest[];
+    filters: {
+        console: string;
+        network: 'all' | 'success' | 'error';
+    };
+}
+/**
+ * Utility function to generate unique IDs for debug entries
+ */
+export declare function generateDebugId(): string;
+/**
+ * Format timestamp for display
+ */
+export declare function formatDebugTimestamp(timestamp: number): string;
+/**
+ * Check if a network request has an error status
+ */
+export declare function isErrorRequest(request: NetworkRequest): boolean;
+/**
+ * Check if a network request is successful
+ */
+export declare function isSuccessRequest(request: NetworkRequest): boolean;

package/dist/utils/editor/argHelpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Strips metadata (like min, max, step) from filter arguments,
+ * returning only the key-value pairs for the backend or PIXI.
+ * Corrected based on expert diff to handle hex color strings.
+ */
+export declare function stripMeta(obj: Record<string, unknown>): Record<string, string | number | boolean>;