@codingfactory/mediables-vue 2.0.1

package/dist/video-engine/index.d.ts

@@ -0,0 +1,14 @@
+export { default } from './VideoEngine';
+export { default as VideoEngine } from './VideoEngine';
+export * as core from './core/mediables-engine.js';
+export { MediablesCompositionAdapter } from './adapters/MediablesCompositionAdapter';
+export { CSSFilterCompositionAdapter } from './adapters/CSSFilterAdapter';
+export { TimelineAdapter } from './adapters/TimelineAdapter';
+export { FilterBridge } from './adapters/FilterBridge';
+export { TransitionManager } from './adapters/TransitionManager';
+export { AudioManager } from './adapters/AudioManager';
+export { TextOverlayManager } from './adapters/TextOverlayManager';
+export { ExportManager } from './adapters/ExportManager';
+export { RenderQueue } from './adapters/RenderQueue';
+export { CSSFilterManager, CSS_FILTER_DEFINITIONS, CSS_FILTER_PRESETS } from './filters/CSSFilterSystem';
+export type * from './types/index';

package/dist/video-engine/presets/ExportPresets.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ExportPresets - Predefined export configurations for different platforms and quality levels
+ * Includes social media presets, quality presets, and custom preset support
+ */
+export interface ExportPreset {
+    id: string;
+    name: string;
+    description?: string;
+    category: 'quality' | 'social' | 'professional' | 'custom';
+    resolution: {
+        width: number;
+        height: number;
+    };
+    fps: number;
+    bitrate?: number;
+    format: 'mp4' | 'webm';
+    aspectRatio?: string;
+    maxDuration?: number;
+    recommendedDuration?: number;
+    icon?: string;
+}
+export interface PresetValidation {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Quality-based presets
+ */
+export declare const QUALITY_PRESETS: ExportPreset[];
+/**
+ * Social media platform presets
+ */
+export declare const SOCIAL_MEDIA_PRESETS: ExportPreset[];
+/**
+ * Professional/broadcast presets
+ */
+export declare const PROFESSIONAL_PRESETS: ExportPreset[];
+/**
+ * All presets combined
+ */
+export declare const ALL_PRESETS: ExportPreset[];
+/**
+ * Get preset by ID
+ */
+export declare function getPresetById(id: string): ExportPreset | undefined;
+/**
+ * Get presets by category
+ */
+export declare function getPresetsByCategory(category: ExportPreset['category']): ExportPreset[];
+/**
+ * Validate custom preset
+ */
+export declare function validatePreset(preset: Partial<ExportPreset>): PresetValidation;
+/**
+ * Create custom preset
+ */
+export declare function createCustomPreset(name: string, options: Partial<ExportPreset>): ExportPreset;
+/**
+ * Get recommended preset based on source video
+ */
+export declare function getRecommendedPreset(sourceWidth: number, sourceHeight: number, purpose?: 'quality' | 'social' | 'fast'): ExportPreset;
+/**
+ * Calculate estimated file size
+ */
+export declare function estimateFileSize(preset: ExportPreset, durationSeconds: number): number;
+/**
+ * Format file size for display
+ */
+export declare function formatFileSize(bytes: number): string;

package/dist/video-engine/types/index.d.ts

@@ -0,0 +1,96 @@
+import type { TimelineClip, AppliedFilter, TextOverlayRecipe, AudioTrackRecipe } from '../../types/video';
+export interface VideoComposition {
+    id?: string;
+    width: number;
+    height: number;
+    fps: number;
+    duration: number;
+    clips: VideoClip[];
+    textOverlays?: TextOverlay[];
+    transitions?: Transition[];
+    audioTracks?: AudioTrack[];
+}
+export type VideoClip = TimelineClip & {
+    inPoint?: number;
+    outPoint?: number;
+    startTime?: number;
+    track?: number;
+};
+export type TextOverlay = TextOverlayRecipe & {
+    id?: string;
+};
+export interface Transition {
+    id: string;
+    type: string;
+    startTime: number;
+    duration: number;
+    fromClipId: string;
+    toClipId: string;
+}
+export type Filter = AppliedFilter;
+export interface ExportOptions {
+    format: 'mp4' | 'webm';
+    quality?: 'low' | 'medium' | 'high';
+    width?: number;
+    height?: number;
+    fps?: number;
+    bitrate?: number;
+    canvas?: {
+        width: number;
+        height: number;
+    };
+    onProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+}
+export interface ExportResult {
+    blob: Blob;
+    url: string;
+    duration: number;
+    size: number;
+}
+export type EngineState = 'idle' | 'ready' | 'playing' | 'paused' | 'exporting' | 'error';
+export interface EngineOptions {
+    canvas?: {
+        width: number;
+        height: number;
+    };
+}
+export type AudioTrack = AudioTrackRecipe;
+export interface TimelineResolvedFrame {
+    sourceFrame: number;
+    clipId: string | null;
+}
+export interface BrowserCapabilities {
+    webgl: boolean;
+    webrtc: boolean;
+    mediaRecorder: boolean;
+    audioContext: boolean;
+    canvas: boolean;
+    videoCodecs: string[];
+    audioCodecs: string[];
+}
+export interface PerformanceMetrics {
+    averageFrameTime: number;
+    peakMemoryUsage: number;
+    totalRenderTime: number;
+    cacheHitRate: number;
+    droppedFrames: number;
+}
+export interface PerformanceBottleneck {
+    type: string;
+    severity: number;
+    description: string;
+    recommendation: string;
+}
+export interface OptimizationSuggestion {
+    type: string;
+    impact: string;
+    description: string;
+    implementation: string;
+}
+export interface MemoryUsage {
+    clips: number;
+    effects: number;
+    total: number;
+}
+export type EngineEvent = 'initialized' | 'destroyed' | 'compositionLoaded' | 'compositionCleared' | 'play' | 'pause' | 'stop' | 'seek' | 'playbackRateChanged' | 'clipAdded' | 'clipRemoved' | 'clipUpdated' | 'clipMuted' | 'filterApplied' | 'filterRemoved' | 'filterUpdated' | 'textOverlayAdded' | 'textOverlayRemoved' | 'textOverlayUpdated' | 'transitionAdded' | 'transitionRemoved' | 'transitionUpdated' | 'audioTrackAdded' | 'audioTrackRemoved' | 'volumeChanged' | 'export-progress' | 'exportComplete' | 'exportError' | 'exportCancelled' | 'frameRendered' | 'previewQualityChanged' | 'error';

package/dist/video-engine/types.d.ts

@@ -0,0 +1 @@
+export * from './types/index';

package/dist/video-engine/utils/EventEmitter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simple EventEmitter for browser compatibility
+ */
+export declare class EventEmitter {
+    private events;
+    on(event: string, listener: Function): this;
+    off(event: string, listener: Function): this;
+    emit(event: string, ...args: any[]): boolean;
+    once(event: string, listener: Function): this;
+    removeAllListeners(event?: string): this;
+    listenerCount(event: string): number;
+}

package/dist/video-engine/utils/MediaSourceResolver.d.ts

@@ -0,0 +1,9 @@
+import type { VideoRecipe } from '@/types/video';
+/**
+ * Resolve a playable media URL for a given recipe.
+ * Order of precedence:
+ * 1) recipe.metadata.source_url
+ * 2) window.MEDIABLES_MEDIA_URLS[media_uuid]
+ * 3) GET /api/media/{media_uuid} -> { playback_url | url }
+ */
+export declare function resolveMediaUrl(recipe: VideoRecipe): Promise<string | undefined>;

package/dist/video-engine/utils/error-reporter.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Error Reporter for Video Engine
+ * Provides utilities for error tracking, reporting, and recovery
+ */
+export interface ErrorReport {
+    id: string;
+    type: ErrorType;
+    severity: ErrorSeverity;
+    message: string;
+    details?: any;
+    stack?: string;
+    context?: ErrorContext;
+    timestamp: number;
+    userAgent: string;
+    url: string;
+    sessionId: string;
+    retryable: boolean;
+    suggestions?: string[];
+}
+export type ErrorType = 'media-load' | 'codec-unsupported' | 'export-failed' | 'memory-exhausted' | 'permission-denied' | 'network-error' | 'composition-invalid' | 'render-failed' | 'unknown';
+export type ErrorSeverity = 'low' | 'medium' | 'high' | 'critical';
+export interface ErrorContext {
+    component?: string;
+    operation?: string;
+    clipId?: string;
+    compositionId?: string;
+    exportFormat?: string;
+    resolution?: {
+        width: number;
+        height: number;
+    };
+    fps?: number;
+    duration?: number;
+    memoryUsage?: number;
+    browser?: BrowserInfo;
+}
+export interface BrowserInfo {
+    name: string;
+    version: string;
+    engine: string;
+    os: string;
+    webCodecs: boolean;
+    webGL: boolean;
+    memory?: number;
+}
+export interface RecoveryStrategy {
+    type: 'retry' | 'fallback' | 'reset' | 'skip';
+    action: () => Promise<void>;
+    description: string;
+}
+declare class ErrorReporter {
+    private static instance;
+    private errors;
+    private sessionId;
+    private reportEndpoint?;
+    private maxErrorsStored;
+    private errorHandlers;
+    private constructor();
+    static getInstance(): ErrorReporter;
+    /**
+     * Configure the error reporter
+     */
+    configure(options: {
+        reportEndpoint?: string;
+        maxErrorsStored?: number;
+        enableAutoReport?: boolean;
+    }): void;
+    /**
+     * Report an error
+     */
+    report(error: Error | ErrorReport, context?: ErrorContext): ErrorReport;
+    /**
+     * Create an error report from an error object
+     */
+    private createErrorReport;
+    /**
+     * Detect error type from error object
+     */
+    private detectErrorType;
+    /**
+     * Calculate error severity
+     */
+    private calculateSeverity;
+    /**
+     * Generate suggestions for error recovery
+     */
+    private generateSuggestions;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryable;
+    /**
+     * Get browser information
+     */
+    private getBrowserInfo;
+    /**
+     * Detect operating system
+     */
+    private detectOS;
+    /**
+     * Check WebGL support
+     */
+    private checkWebGL;
+    /**
+     * Store error in memory
+     */
+    private storeError;
+    /**
+     * Send error report to server
+     */
+    private sendToServer;
+    /**
+     * Register an error handler for specific error type
+     */
+    onError(type: ErrorType, handler: (error: ErrorReport) => void): void;
+    /**
+     * Call registered error handlers
+     */
+    private callHandlers;
+    /**
+     * Get recovery strategies for an error
+     */
+    getRecoveryStrategies(report: ErrorReport): RecoveryStrategy[];
+    /**
+     * Get recent errors
+     */
+    getRecentErrors(count?: number): ErrorReport[];
+    /**
+     * Clear error history
+     */
+    clearErrors(): void;
+    /**
+     * Generate unique ID
+     */
+    private generateId;
+    /**
+     * Generate session ID
+     */
+    private generateSessionId;
+    /**
+     * Setup global error handlers
+     */
+    private setupGlobalErrorHandlers;
+    /**
+     * Export error report as JSON
+     */
+    exportReport(): string;
+    /**
+     * Export error report as CSV
+     */
+    exportCSV(): string;
+}
+export declare const errorReporter: ErrorReporter;
+export declare function reportError(error: Error, context?: ErrorContext): ErrorReport;
+export declare function getRecoveryStrategies(error: ErrorReport): RecoveryStrategy[];
+export declare function getRecentErrors(count?: number): ErrorReport[];
+export declare function clearErrors(): void;
+export declare function exportErrorReport(): string;
+export {};

package/dist/video-engine/utils/keyboard-shortcuts.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Keyboard Shortcuts Manager for Video Engine
+ * Provides keyboard shortcuts for video editing operations
+ */
+export interface KeyboardShortcut {
+    id: string;
+    key: string;
+    modifiers?: Array<'ctrl' | 'cmd' | 'alt' | 'shift'>;
+    action: () => void;
+    description: string;
+    category: string;
+    enabled?: boolean;
+    preventDefault?: boolean;
+}
+export interface ShortcutCategory {
+    name: string;
+    shortcuts: KeyboardShortcut[];
+}
+declare class KeyboardShortcutsManager {
+    private shortcuts;
+    private enabled;
+    private listeners;
+    private pressedKeys;
+    private platform;
+    constructor();
+    /**
+     * Detect the operating system platform
+     */
+    private detectPlatform;
+    /**
+     * Setup keyboard event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Register default video engine shortcuts
+     */
+    private registerDefaultShortcuts;
+    /**
+     * Handle keydown event
+     */
+    private handleKeyDown;
+    /**
+     * Handle keyup event
+     */
+    private handleKeyUp;
+    /**
+     * Find matching shortcut for keyboard event
+     */
+    private findShortcut;
+    /**
+     * Check if event matches shortcut
+     */
+    private matchesShortcut;
+    /**
+     * Register a keyboard shortcut
+     */
+    register(shortcut: KeyboardShortcut): void;
+    /**
+     * Unregister a keyboard shortcut
+     */
+    unregister(id: string): void;
+    /**
+     * Enable/disable shortcuts
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Enable/disable specific shortcut
+     */
+    setShortcutEnabled(id: string, enabled: boolean): void;
+    /**
+     * Update shortcut key binding
+     */
+    updateShortcut(id: string, key: string, modifiers?: Array<'ctrl' | 'cmd' | 'alt' | 'shift'>): void;
+    /**
+     * Get all shortcuts grouped by category
+     */
+    getShortcutsByCategory(): ShortcutCategory[];
+    /**
+     * Get shortcut display string
+     */
+    getShortcutDisplay(id: string): string;
+    /**
+     * Listen for shortcut events
+     */
+    on(event: string, handler: () => void): void;
+    /**
+     * Remove event listener
+     */
+    off(event: string, handler: () => void): void;
+    /**
+     * Emit event
+     */
+    private emit;
+    /**
+     * Export shortcuts configuration
+     */
+    exportConfig(): Record<string, any>;
+    /**
+     * Import shortcuts configuration
+     */
+    importConfig(config: Record<string, any>): void;
+    /**
+     * Reset to default shortcuts
+     */
+    resetToDefaults(): void;
+    /**
+     * Check if key is currently pressed
+     */
+    isKeyPressed(key: string): boolean;
+    /**
+     * Get help text for all shortcuts
+     */
+    getHelpText(): string;
+}
+export declare const keyboardShortcuts: KeyboardShortcutsManager;
+export declare function registerShortcut(shortcut: KeyboardShortcut): void;
+export declare function onShortcut(event: string, handler: () => void): void;
+export declare function getShortcutDisplay(id: string): string;
+export declare function enableShortcuts(enabled?: boolean): void;
+export {};

package/dist/video-engine/utils/pixi-video-fallback.d.ts

@@ -0,0 +1,2 @@
+import * as PIXI from 'pixi.js';
+export declare function createPixiVideoFallbackFilter(filterId: string, params: Record<string, unknown>): PIXI.Filter | null;