@codingfactory/mediables-vue 2.0.1

package/dist/filters/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Filters Module Index
+ * Exports all filter-related functionality
+ */
+import { registerFilter, getFilter, getAllFilters, getFiltersByCategory, getAllCategories, hasFilter, getRegisteredFilters, registerCorePixiFilters } from './registry';
+export { registerFilter, getFilter, getAllFilters, getFiltersByCategory, getAllCategories, hasFilter, getRegisteredFilters, registerCorePixiFilters, };
+export type { FilterDefinition, ControlDefinition } from './registry';
+export { createFilterInstance, createFilterInstances, updateFilterParams, } from './factory';
+export type { FilterInstanceConfig } from './factory';
+export { mapControlTypeToComponent, validateControlValue, generateDefaultParams, convertControlValue, } from './controlMapping';
+import './definitions/adjustment';
+import './definitions/adjustmentAdvanced';
+import './definitions/alpha';
+import './definitions/blur';
+import './definitions/colorMatrix';
+import './definitions/colorOverlay';
+import './definitions/dropShadow';
+import './definitions/grayscale';
+import './definitions/hslAdjustment';
+import './definitions/kawaseBlur';
+import './definitions/motionBlur';
+import './definitions/radialBlur';
+import './definitions/tiltShift';
+import './definitions/zoomBlur';
+import './definitions/colorGradient';
+import './definitions/colorMap';
+import './definitions/colorReplace';
+import './definitions/multiColorReplace';
+import './definitions/rgbSplit';
+import './definitions/advancedBloom';
+import './definitions/ascii';
+import './definitions/backdropBlur';
+import './definitions/bevel';
+import './definitions/bloom';
+import './definitions/bulgePinch';
+import './definitions/convolution';
+import './definitions/crossHatch';
+import './definitions/crt';
+import './definitions/displacement';
+import './definitions/dot';
+import './definitions/emboss';
+import './definitions/glitch';
+import './definitions/glow';
+import './definitions/godray';
+import './definitions/lightmap';
+import './definitions/noise';
+import './definitions/oldFilm';
+import './definitions/outline';
+import './definitions/pixelate';
+import './definitions/reflection';
+import './definitions/shockwave';
+import './definitions/simplexNoise';
+import './definitions/twist';
+import './definitions/vignette';
+/**
+ * Initialize the filter registry with all available filters
+ * This function can be called explicitly to ensure all filters are registered
+ *
+ * This version uses direct function calls as "require" is not available in this environment
+ */
+export declare function initializeFilterRegistry(): any[];
+/**
+ * Alternative initialization function with a minimal approach
+ * Use this if the main initializeFilterRegistry function is having issues
+ */
+export declare function safeInitializeFilterRegistry(): Promise<import("./registry").FilterDefinition[]>;
+/**
+ * Simplified factory for creating a minimal filter
+ * Returns a no-op filter that won't cause errors but doesn't do anything
+ */
+export declare function createMinimalFilter(id: string): {
+    id: string;
+    name: string;
+    enabled: boolean;
+    apply: () => void;
+    uniforms: {};
+    updateUIParam: (param: string, value: any) => boolean;
+    handleButtonAction: (action: string) => boolean;
+    reset: () => void;
+    clone: () => {
+        id: string;
+        name: string;
+        enabled: boolean;
+        apply: () => void;
+        uniforms: {};
+        updateUIParam: (param: string, value: any) => boolean;
+        handleButtonAction: (action: string) => boolean;
+        reset: () => void;
+        clone: /*elided*/ any;
+        [Symbol.toPrimitive]: () => string;
+    };
+    [Symbol.toPrimitive]: () => string;
+};

package/dist/filters/registry.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Filter Registry System
+ * Centralized storage and management for filter definitions
+ */
+type Filter = any;
+/**
+ * Interface for a filter control definition
+ * Defines the UI representation of a filter parameter
+ */
+export interface ControlDefinition {
+    id: string;
+    type: 'slider' | 'toggle' | 'color' | 'select' | 'range' | 'button' | 'text';
+    label: string;
+    property?: string;
+    action?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    default?: number | boolean | string;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    tooltip?: string;
+}
+/**
+ * Interface for a filter definition
+ * Contains all metadata needed to create and manage a filter
+ */
+export interface FilterDefinition {
+    id: string;
+    name: string;
+    category: string;
+    description?: string;
+    thumbnail?: string;
+    createFilter: (params: Record<string, any>) => Filter;
+    defaultParams: Record<string, any>;
+    controls: ControlDefinition[];
+}
+/**
+ * Register a filter in the global registry
+ * @param definition The filter definition to register
+ * @returns The provided filter definition (for chaining)
+ */
+export declare function registerFilter(definition: FilterDefinition): FilterDefinition;
+/**
+ * Get a filter definition by ID
+ * @param id The ID of the filter to retrieve
+ * @returns The filter definition or undefined if not found
+ */
+export declare function getFilter(id: string): FilterDefinition | undefined;
+/**
+ * Get all registered filter definitions
+ * @returns Array of all registered filter definitions
+ */
+export declare function getAllFilters(): FilterDefinition[];
+/**
+ * Register all core PixiJS filters if they don't already have custom definitions,
+ * but only using the actual custom definitions from their respective files.
+ */
+export declare function registerCorePixiFilters(): void;
+/**
+ * Get all filters in a specific category
+ * @param category The category to retrieve filters for
+ * @returns Array of filter definitions in the requested category
+ */
+export declare function getFiltersByCategory(category: string): FilterDefinition[];
+/**
+ * Get all filter categories
+ * @returns Array of category names
+ */
+export declare function getAllCategories(): string[];
+/**
+ * Check if a filter is registered
+ * @param id The ID of the filter to check
+ * @returns True if the filter is registered, false otherwise
+ */
+export declare function hasFilter(id: string): boolean;
+/**
+ * Get all registered filters with simplified format for UI
+ * @returns Array of filter definitions with only UI-relevant properties
+ */
+export declare function getRegisteredFilters(): Array<{
+    id: string;
+    name: string;
+    category: string;
+    controls: ControlDefinition[];
+}>;
+export {};

package/dist/filters/video-compatible.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Video-Compatible Filter Definitions
+ *
+ * Deterministic subset of filters that work identically in both:
+ * - PIXI.js (for real-time preview in browser)
+ * - FFmpeg (for server-side processing)
+ *
+ * Each filter must produce identical results in both environments
+ */
+import type { VideoFilterDefinition } from '../types/video';
+/**
+ * Curated list of 15 deterministic filters
+ * These filters are guaranteed to produce identical results
+ * in both PIXI.js preview and FFmpeg export
+ */
+export declare const VIDEO_COMPATIBLE_FILTERS: VideoFilterDefinition[];
+/**
+ * Generate FFmpeg filter command from filter ID and parameters
+ */
+export declare function getFFmpegFilter(filterId: string, params: Record<string, any>): string;
+/**
+ * Build complete FFmpeg filter complex from multiple filters
+ */
+export declare function buildFFmpegFilterComplex(filters: Array<{
+    id: string;
+    params: Record<string, any>;
+}>): string;
+/**
+ * Get filter by ID
+ */
+export declare function getFilterDefinition(filterId: string): VideoFilterDefinition | undefined;
+/**
+ * Get filters by category
+ */
+export declare function getFiltersByCategory(category: VideoFilterDefinition['category']): VideoFilterDefinition[];
+/**
+ * Validate filter parameters
+ */
+export declare function validateFilterParams(filterId: string, params: Record<string, any>): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Export filter categories for UI
+ */
+export declare const FILTER_CATEGORIES: readonly [{
+    readonly id: "color";
+    readonly name: "Color";
+    readonly icon: "color-palette-outline";
+}, {
+    readonly id: "blur";
+    readonly name: "Blur";
+    readonly icon: "eye-off-outline";
+}, {
+    readonly id: "stylize";
+    readonly name: "Stylize";
+    readonly icon: "brush-outline";
+}, {
+    readonly id: "effects";
+    readonly name: "Effects";
+    readonly icon: "sparkles-outline";
+}, {
+    readonly id: "transform";
+    readonly name: "Transform";
+    readonly icon: "resize-outline";
+}];
+/**
+ * Get default parameters for a filter
+ */
+export declare function getDefaultParams(filterId: string): Record<string, any>;
+/**
+ * Create a filter preset from current filters
+ */
+export declare function createFilterPreset(name: string, filters: Array<{
+    id: string;
+    params: Record<string, any>;
+}>): any;

package/dist/filters/video-css-filters.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Video-specific CSS filters
+ * These filters use native CSS filter functions for reliable video rendering
+ */
+export interface VideoCSSFilter {
+    id: string;
+    name: string;
+    category: string;
+    icon?: string;
+    previewImage?: string;
+    cssFilter: string;
+    defaultParams?: Record<string, any>;
+}
+/**
+ * Curated list of CSS filters optimized for video
+ * These are guaranteed to work with video export
+ */
+export declare const VIDEO_CSS_FILTERS: VideoCSSFilter[];
+/**
+ * Get filter categories for UI
+ */
+export declare const VIDEO_FILTER_CATEGORIES: {
+    id: string;
+    name: string;
+    icon: string;
+}[];
+/**
+ * Quick presets for one-click application
+ */
+export declare const VIDEO_FILTER_PRESETS: {
+    instagram: {
+        valencia: ({
+            filterId: string;
+            params: {
+                amount: number;
+                value?: undefined;
+            };
+        } | {
+            filterId: string;
+            params: {
+                value: number;
+                amount?: undefined;
+            };
+        })[];
+        nashville: ({
+            filterId: string;
+            params: {
+                amount: number;
+                value?: undefined;
+                degrees?: undefined;
+            };
+        } | {
+            filterId: string;
+            params: {
+                value: number;
+                amount?: undefined;
+                degrees?: undefined;
+            };
+        } | {
+            filterId: string;
+            params: {
+                degrees: number;
+                amount?: undefined;
+                value?: undefined;
+            };
+        })[];
+        hudson: {
+            filterId: string;
+            params: {
+                value: number;
+            };
+        }[];
+    };
+    professional: {
+        broadcast: {
+            filterId: string;
+            params: {
+                value: number;
+            };
+        }[];
+        documentary: ({
+            filterId: string;
+            params: {
+                value: number;
+                radius?: undefined;
+                darkness?: undefined;
+            };
+        } | {
+            filterId: string;
+            params: {
+                radius: number;
+                darkness: number;
+                value?: undefined;
+            };
+        })[];
+        news: {
+            filterId: string;
+            params: {
+                value: number;
+            };
+        }[];
+    };
+    moods: {
+        happy: {
+            filterId: string;
+            params: {
+                value: number;
+            };
+        }[];
+        moody: ({
+            filterId: string;
+            params: {
+                value: number;
+                color?: undefined;
+                intensity?: undefined;
+            };
+        } | {
+            filterId: string;
+            params: {
+                color: string;
+                intensity: number;
+                value?: undefined;
+            };
+        })[];
+        energetic: {
+            filterId: string;
+            params: {
+                value: number;
+            };
+        }[];
+        calm: ({
+            filterId: string;
+            params: {
+                value: number;
+                radius?: undefined;
+            };
+        } | {
+            filterId: string;
+            params: {
+                radius: number;
+                value?: undefined;
+            };
+        })[];
+    };
+};
+/**
+ * Helper to convert legacy PIXI filter to CSS filter
+ */
+export declare function convertPixiToCSSFilter(pixiFilter: any): any;
+/**
+ * Export for backward compatibility
+ */
+export declare const videoCompatibleFilters: VideoCSSFilter[];