@codingfactory/mediables-vue 2.11.0 → 2.13.0

package/dist/vanilla-editor/renderer/FilterManager.d.ts

@@ -0,0 +1,132 @@
+export class FilterManager extends EventEmitter {
+    constructor(state: any, pixiRenderer: any);
+    state: any;
+    renderer: any;
+    instances: {};
+    _filterRegistry: Object | null;
+    /**
+     * Set the filter registry (from mediables/filters)
+     * @param {Object} registry - { getFilter, getAllFilters, getFiltersByCategory }
+     */
+    setRegistry(registry: Object): void;
+    /**
+     * Get filter definition by ID
+     * @param {string} filterId
+     * @returns {Object|null}
+     */
+    getFilterDef(filterId: string): Object | null;
+    /**
+     * Get all filters
+     * @returns {Array}
+     */
+    getAllFilters(): any[];
+    /**
+     * Get filters by category
+     * Maps UI category names to registry category names
+     * @param {string} category - UI category ID
+     * @returns {Array}
+     */
+    getFiltersByCategory(category: string): any[];
+    /**
+     * Normalize UI values from various input types
+     * @param {*} value
+     * @returns {*}
+     */
+    _normalizeValue(value: any): any;
+    /**
+     * Get a deep property from an object.
+     * Returns undefined if any segment along the path is missing.
+     * @param {Object} target
+     * @param {string} path
+     * @returns {*}
+     */
+    _getDeepProp(target: Object, path: string): any;
+    /**
+     * Set a deep property on an object
+     * @param {Object} target
+     * @param {string} path
+     * @param {*} value
+     */
+    _setDeepProp(target: Object, path: string, value: any): void;
+    /**
+     * Initialize filter values from definition defaults.
+     * Seeds BOTH defaultParams (e.g. colorStops) and control defaults so that
+     * filters with dynamic parameters not backed by a static control still have
+     * their state populated.
+     * @param {string} filterId
+     */
+    initializeValues(filterId: string, expectedLayerId?: undefined): void;
+    /**
+     * Reset all filter values to their defaults (unconditionally).
+     * Resets BOTH defaultParams and control defaults.
+     * @param {string} filterId
+     */
+    resetValues(filterId: string, expectedLayerId?: undefined): void;
+    /**
+     * Toggle a filter on/off
+     * @param {string} filterId
+     * @param {boolean} enabled
+     */
+    toggle(filterId: string, enabled: boolean, expectedLayerId?: undefined): boolean;
+    /**
+     * Update a filter control value.
+     *
+     * The `controlId` may be either a static control id (from def.controls) or a
+     * dynamic path (e.g. 'colorStops[0].color') produced by a filter's
+     * getDynamicControls(). Static control ids are stored in state keyed by the
+     * control id. Dynamic paths are NOT stored as flat path keys — instead, we
+     * apply them to the live instance and then sync the filter's serializable
+     * params back into state, so recreation via applyFilters() rebuilds from
+     * the canonical shape (e.g. a colorStops array, not 'colorStops[0].color').
+     *
+     * Returns true when the filter was updated in-place. Returns false when the
+     * caller should invoke applyFilters() to recreate the filter from state —
+     * this happens when the property target is a method (which would be
+     * silently corrupted by a direct write) or when the property doesn't exist.
+     *
+     * @param {string} filterId
+     * @param {string} controlId - Static control id or dynamic property path
+     * @param {*} value
+     * @returns {boolean} True if updated in-place, false if caller must recreate
+     */
+    updateValue(filterId: string, controlId: string, value: any, expectedLayerId?: undefined): boolean;
+    /**
+     * Perform a filter action (e.g. addColorStop, removeColorStop) and sync
+     * any resulting state changes back into State.js before recreating the
+     * filter. Without this sync, recreation via applyFilters() would rebuild
+     * from stale state and undo the action.
+     *
+     * @param {string} filterId
+     * @param {string} action - Action name understood by filter.updateUIParam
+     */
+    performFilterAction(filterId: string, action: string, expectedLayerId?: undefined): boolean;
+    _matchesExpectedFilterLayer(expectedLayerId: any): boolean;
+    _layerDocument(): any;
+    _sourceDimensionsForLayer(layer: any, context?: {}): {
+        width: number;
+        height: number;
+    };
+    _paramsForFilterState(def: any, filterState: any, dimensions: any): any;
+    createFiltersForLayer(layer: any, context?: {}): any[];
+    /**
+     * Apply all active filters to the sprite
+     *
+     * This method recreates all filter instances on each call to ensure
+     * PIXI v8's filter pipeline correctly processes changes.
+     */
+    applyFilters(): void;
+    /**
+     * Reset all filters.
+     * IMPORTANT: Only clears filter instances and sprite.filters.
+     * Does NOT touch baseTexture/originalTexture/sprite — that would
+     * destroy any applied crop, which is a separate concern.
+     */
+    resetAll(expectedLayerId?: undefined): boolean;
+    /**
+     * Get a filter instance
+     * @param {string} filterId
+     * @returns {Object|null}
+     */
+    getInstance(filterId: string): Object | null;
+}
+import { EventEmitter } from '../core/EventEmitter.js';

package/dist/vanilla-editor/renderer/PixiRenderer.d.ts

@@ -0,0 +1,274 @@
+export class PixiRenderer extends EventEmitter {
+    app: any;
+    sprite: any;
+    originalTexture: any;
+    baseTexture: any;
+    fitScale: number;
+    zoom: number;
+    _container: HTMLElement | null;
+    _lastExportDimensions: {
+        width: number;
+        height: number;
+    } | null;
+    /** @type {Promise<boolean>|null} Resolves when mount() finishes */
+    _mountPromise: Promise<boolean> | null;
+    _mountToken: number;
+    _destroyed: boolean;
+    _layerDocument: any;
+    _layerDisplayObjects: Map<any, any>;
+    _renderableLayerIds: any[];
+    _loadedTextureUrl: string | null;
+    _layerRenderToken: number;
+    _layerFilterFactory: any;
+    /**
+     * Whether the renderer is fully initialized and ready for use.
+     * @returns {boolean}
+     */
+    get isReady(): boolean;
+    /**
+     * Get CSS size of the canvas (for proper coordinate mapping).
+     * Accesses renderer.canvas directly to avoid PIXI Application's
+     * canvas getter which throws when renderer is undefined.
+     */
+    _getCssSize(): {
+        w: any;
+        h: any;
+    };
+    /**
+     * Force render the stage
+     */
+    render(): void;
+    /**
+     * Wait for the next animation frame, with a timeout fallback for environments
+     * where the frame callback never arrives while the editor is open.
+     * @param {number} timeoutMs
+     * @returns {Promise<void>}
+     */
+    _waitForNextFrame(timeoutMs?: number): Promise<void>;
+    /**
+     * Calculate fit scale for a texture
+     * @param {PIXI.Texture} tex
+     * @returns {number}
+     */
+    getFitScaleFor(tex: PIXI.Texture): number;
+    /**
+     * Apply view transform (position and scale) to sprite
+     */
+    applyViewTransform(opts?: {}): void;
+    /**
+     * Set zoom level
+     * @param {number} z - Zoom level (0.1 to 8)
+     * @param {Object} opts - Options
+     */
+    setZoom(z: number, opts?: Object): void;
+    /**
+     * Fit image to screen
+     */
+    fitToScreen(): void;
+    /**
+     * Mount PIXI application to container
+     * @param {HTMLElement} container
+     * @param {number} backgroundColor
+     * @param {Object} [options]
+     * @param {number} [options.backgroundAlpha=1] - 0 makes the canvas transparent
+     *   so a host-rendered background (e.g. CSS checkerboard) shows through.
+     */
+    mount(container: HTMLElement, backgroundColor?: number, options?: {
+        backgroundAlpha?: number | undefined;
+    }): Promise<boolean | undefined>;
+    /**
+     * Load an image texture
+     * @param {string} imageUrl - URL, data URL, or blob URL of the image
+     * @param {Object} [options]
+     * @param {() => boolean} [options.isCurrent] - Returns false when this load
+     *   has been superseded and must not mutate the renderer.
+     */
+    loadTexture(imageUrl: string, options?: {
+        isCurrent?: (() => boolean) | undefined;
+    }): Promise<boolean>;
+    /**
+     * Render a v2 layer document in preview order. The existing subject sprite
+     * remains the filter/crop target; auxiliary layers are synced to its preview
+     * geometry until arbitrary per-layer transforms are introduced.
+     * @param {Object|null} document
+     * @returns {Promise<boolean>}
+     */
+    renderLayerDocument(document: Object | null): Promise<boolean>;
+    getRenderableLayerIds(): any[];
+    setLayerFilterFactory(factory: any): void;
+    applyLayerFilters(document?: any): boolean;
+    _isSubjectLayer(layer: any): boolean;
+    _layerSupportsImageFilters(layer: any): boolean;
+    _layerOpacity(layer: any): number;
+    _applyLayerFilterInstances(displayObject: any, layer: any, context?: {}): void;
+    _createDisplayObjectForLayer(PIXI: any, layer: any): Promise<any>;
+    _isTextLayer(layer: any): boolean;
+    _normalizeTextBox(layer: any): {
+        x: any;
+        y: any;
+        width: any;
+        height: any;
+    };
+    _clampNumber(value: any, min: any, max: any, fallback: any): any;
+    _supportedTextFontFamily(value: any): string;
+    _supportedTextColor(value: any, fallback?: string): string;
+    _textBlendMode(layer: any): any;
+    _textContentForLayer(layer: any): string;
+    _textStyleForLayer(layer: any, scale?: number, wordWrapWidth?: number, options?: {}): {
+        fontFamily: string;
+        fontSize: number;
+        fontWeight: number;
+        fontStyle: any;
+        fill: any;
+        align: any;
+        lineHeight: number;
+        letterSpacing: number;
+        wordWrap: boolean;
+        wordWrapWidth: number;
+        breakWords: boolean;
+    };
+    _normalizeTextFontWeight(value: any): number;
+    _textEffectsForLayer(layer: any): {
+        stroke: {
+            enabled: boolean;
+            color: string;
+            width: any;
+        };
+        shadow: {
+            enabled: boolean;
+            color: string;
+            alpha: any;
+            blur: any;
+            distance: any;
+            angle: number;
+        };
+        glow: {
+            enabled: boolean;
+            color: string;
+            alpha: any;
+            blur: any;
+        };
+        backdrop: {
+            enabled: boolean;
+            color: string;
+            opacity: any;
+            padding: any;
+            radius: any;
+            blur: any;
+        };
+    };
+    _createTextBlurFilter(PIXI: any, amount: any): any;
+    _textEffectPadding(effects: any, scale: any): number;
+    _createTextDisplayObjectForLayer(PIXI: any, layer: any): any;
+    _createTextPrimitive(PIXI: any, layer: any): any;
+    _createSubjectDisplayObjectForLayer(PIXI: any, layer: any): Promise<any>;
+    _createImageDisplayObjectForLayer(PIXI: any, layer: any): Promise<any>;
+    _backgroundFillForLayer(layer: any): any;
+    _backgroundColorForLayer(layer: any): any;
+    _sourceUrlForLayerSource(source: any): string | null;
+    _textureForLayerSource(PIXI: any, source: any): Promise<any>;
+    _createBackgroundSprite(PIXI: any, texture: any, fit?: string): any;
+    _createGradientTexture(PIXI: any, fill: any, width: any, height: any): any;
+    _backgroundBlurAmount(layer: any): number;
+    _applyLayerEffects(PIXI: any, displayObject: any, layer: any): void;
+    _syncLayerDisplayObjects(): void;
+    _syncLayerDisplayObject(layer: any, displayObject: any): void;
+    _fillTextEffectGraphics(graphics: any, color: any, alpha?: number): void;
+    _syncTextEffectPrimitive(PIXI: any, primitive: any, layer: any, effects: any, kind: any, scale: any, width: any, effectMask: any): void;
+    _syncTextBackdrop(PIXI: any, backdrop: any, effects: any, scale: any, width: any, height: any, effectMask: any): void;
+    _fitTextDisplayObjectToRect(displayObject: any, layer: any, rect: any): void;
+    _fitDisplayObjectToRect(displayObject: any, layer: any, rect: any): void;
+    _destroyLayerDisplayObjects(): void;
+    _destroyTransientDisplayObject(displayObject: any): void;
+    /**
+     * Normalize degrees to the 0..360 range.
+     * @param {number} degrees
+     * @returns {number}
+     */
+    _normalizeDegrees(degrees: number): number;
+    /**
+     * Calculate the axis-aligned bounds for a rotated rectangle.
+     * @param {number} width
+     * @param {number} height
+     * @param {number} degrees
+     * @returns {{ width: number, height: number }}
+     */
+    getRotatedBounds(width: number, height: number, degrees: number): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Permanently rotate the working texture. This keeps crop math simple:
+     * after rotation, sprite coordinates and texture dimensions both describe
+     * the visible image exactly.
+     *
+     * @param {number} degrees Clockwise degrees to add to the working texture.
+     * @returns {boolean}
+     */
+    rotateBy(degrees: number): boolean;
+    /**
+     * Export the current image with filters applied.
+     *
+     * @param {string} format - 'png' or 'jpeg'
+     * @param {number} quality - Quality for jpeg (0-1)
+     * @param {number} maxEdge - Maximum edge size in pixels (0 for original)
+     * @param {boolean} dontUpscale - Don't upscale smaller images
+     * @param {number} [maxPixels=0] - Max total pixel count (width*height). 0 disables.
+     *   Backend API often limits payload size (blowglass caps at 8M pixels); set this
+     *   to keep the export under that cap while preserving aspect ratio.
+     * @returns {string|null} Data URL
+     */
+    exportImage(format?: string, quality?: number, maxEdge?: number, dontUpscale?: boolean, maxPixels?: number): string | null;
+    /**
+     * Get the actual export dimensions at the current filter state.
+     *
+     * When an export has been performed, returns the exact trimmed dimensions
+     * from that export. Otherwise falls back to source texture size plus a
+     * rough filter-padding estimate — the real dimensions are only known for
+     * certain after exportImage() runs the bbox scan.
+     *
+     * @returns {{ width: number, height: number }}
+     */
+    getExportDimensions(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Export the current image as a Blob with correct dimensions.
+     * @param {string} format - 'png' or 'jpeg'
+     * @param {number} quality - Quality for jpeg (0-1)
+     * @param {{ maxPixels?: number, maxEdge?: number, dontUpscale?: boolean }} [options]
+     * @returns {Promise<{ blob: Blob, width: number, height: number } | null>}
+     */
+    exportBlob(format?: string, quality?: number, options?: {
+        maxPixels?: number;
+        maxEdge?: number;
+        dontUpscale?: boolean;
+    }): Promise<{
+        blob: Blob;
+        width: number;
+        height: number;
+    } | null>;
+    /**
+     * Resize renderer to container
+     * @param {HTMLElement} container
+     */
+    resizeTo(container: HTMLElement): void;
+    /**
+     * Set background color
+     * @param {number} color - Hex color
+     */
+    setBackgroundColor(color: number): void;
+    /**
+     * Load an image URL into an HTMLImageElement.
+     * Handles blob:, data:, and http(s): URLs.
+     * @param {string} url
+     * @returns {Promise<HTMLImageElement|null>}
+     */
+    _loadImageElement(url: string): Promise<HTMLImageElement | null>;
+    /**
+     * Clean up and destroy
+     */
+    destroy(): void;
+}
+import { EventEmitter } from '../core/EventEmitter.js';

package/dist/vanilla-editor/renderer/RemoveBgManager.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Background Removal Manager for the vanilla image editor
+ * Handles communication with the background removal service
+ */
+export class RemoveBgManager {
+    /**
+     * Create a new RemoveBgManager
+     * @param {Object} options
+     * @param {string} [options.endpoint] - API endpoint for uploaded preview background removal
+     * @param {string} [options.optionsEndpoint] - API endpoint for background-removal capability/options
+     * @param {string} [options.savedEndpoint] - API endpoint template for saved-media removal
+     * @param {string} [options.fallbackEndpoint] - Fallback endpoint if primary fails
+     */
+    constructor(options?: {
+        endpoint?: string | undefined;
+        optionsEndpoint?: string | undefined;
+        savedEndpoint?: string | undefined;
+        fallbackEndpoint?: string | undefined;
+    });
+    _endpoint: string;
+    _optionsEndpoint: string;
+    _savedEndpoint: string;
+    _fallbackEndpoint: string | null;
+    _activeControllers: Set<any>;
+    _createAbortController(): AbortController | null;
+    _releaseAbortController(controller: any): void;
+    cancelActiveRequests(reason?: string): number;
+    /**
+     * Build a stable preview request so callers can stale-guard the response.
+     * @param {string|Blob} imageData
+     * @param {Object} options
+     * @returns {Promise<Object>}
+     */
+    preparePreviewRequest(imageData: string | Blob, options?: Object): Promise<Object>;
+    /**
+     * @param {string|Blob} imageData
+     * @returns {Promise<string>}
+     */
+    computeImageDataHash(imageData: string | Blob): Promise<string>;
+    /**
+     * Remove background from an image
+     * @param {string} imageData - Data URL or Blob of the image
+     * @param {Object} options
+     * @param {string} [options.tier='balanced'] - Quality tier: 'fast', 'balanced', 'best'
+     * @param {string} [options.model] - Explicit model name (overrides tier)
+     * @param {boolean} [options.alpha_matting=false] - Enable alpha matting for edge refinement
+     * @param {number} [options.alpha_f=10] - Alpha matting foreground threshold
+     * @param {number} [options.alpha_fr=15] - Alpha matting foreground radius
+     * @param {number} [options.alpha_erode_size=10] - Alpha matting erode size
+     * @returns {Promise<{dataUrl: string, model: string, processMs: string}>}
+     */
+    removeBackground(imageData: string, options?: {
+        tier?: string | undefined;
+        model?: string | undefined;
+        alpha_matting?: boolean | undefined;
+        alpha_f?: number | undefined;
+        alpha_fr?: number | undefined;
+        alpha_erode_size?: number | undefined;
+    }): Promise<{
+        dataUrl: string;
+        model: string;
+        processMs: string;
+    }>;
+    /**
+     * Remove the background from a persisted editor-document layer.
+     * @param {Object} options
+     * @param {string} options.targetMediaUuid
+     * @param {string} options.operationId
+     * @param {string} options.documentId
+     * @param {string} options.documentRevisionId
+     * @param {string} options.targetLayerId
+     * @param {string} options.expectedSourceHash
+     * @param {string} [options.tier]
+     * @returns {Promise<Object>}
+     */
+    removeSavedMediaBackground(options: {
+        targetMediaUuid: string;
+        operationId: string;
+        documentId: string;
+        documentRevisionId: string;
+        targetLayerId: string;
+        expectedSourceHash: string;
+        tier?: string | undefined;
+    }): Promise<Object>;
+    /**
+     * Convert a data URL to a Blob
+     * @param {string} dataUrl
+     * @returns {Promise<Blob>}
+     */
+    _dataUrlToBlob(dataUrl: string): Promise<Blob>;
+    /**
+     * Convert a Blob to a data URL
+     * @param {Blob} blob
+     * @returns {Promise<string>}
+     */
+    _blobToDataUrl(blob: Blob): Promise<string>;
+    /**
+     * Check if the background removal service is available
+     * @returns {Promise<boolean>}
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * @returns {Promise<Object>}
+     */
+    getOptions(): Promise<Object>;
+    _uuid(): string;
+    _sha256Hex(blob: any): Promise<string>;
+}