@yogiswara/honcho-editor-ui 2.7.13 → 2.7.14

package/dist/hooks/usePreset.d.ts

@@ -1,82 +0,0 @@
-import { Controller, Preset, AdjustmentState } from './editor/type';
-/**
- * Configuration options for the preset hook
- */
-export interface PresetOptions {
-    /** Enable development warnings for debugging */
-    devWarnings?: boolean;
-    /** Auto-load presets on hook initialization */
-    autoLoad?: boolean;
-}
-/**
- * Information about the current preset state
- */
-export interface PresetInfo {
-    /** Whether presets are currently being loaded */
-    isLoading: boolean;
-    /** Error message if any operation failed */
-    error: string | null;
-    /** Number of presets currently managed */
-    count: number;
-    /** Whether the hook has been initialized */
-    isInitialized: boolean;
-}
-/**
- * Actions available for preset management
- */
-export interface PresetActions {
-    /** Create a new preset */
-    create: (name: string, settings: AdjustmentState) => Promise<Preset | null>;
-    /** Rename an existing preset */
-    rename: (presetId: string, newName: string) => Promise<boolean>;
-    /** Delete a preset */
-    delete: (presetId: string) => Promise<boolean>;
-    /** Load/refresh presets from backend */
-    load: () => Promise<void>;
-    /** Find preset that matches the given adjustment state */
-    findByAdjustments: (adjustments: AdjustmentState) => Preset | null;
-}
-/**
- * Return type for the usePreset hook
- */
-export interface UsePresetReturn {
-    /** Current list of presets */
-    presets: Preset[];
-    /** Information about preset state */
-    info: PresetInfo;
-    /** Available preset actions */
-    actions: PresetActions;
-}
-/**
- * Hook for managing presets with backend communication through Controller.
- *
- * **Key Features:**
- * - **Backend Communication**: All operations go through the provided Controller
- * - **Local State Management**: Maintains local preset list for UI performance
- * - **CRUD Operations**: Create, rename, delete, and list presets
- * - **Error Handling**: Provides error states for failed operations
- * - **Auto-loading**: Optional automatic preset loading on initialization
- *
- * **Typical Usage:**
- * ```typescript
- * const { presets, actions, info } = usePreset(controller, firebaseUid, { autoLoad: true });
- *
- * // Create preset
- * const newPreset = await actions.create('My Preset', adjustmentState);
- *
- * // Rename preset
- * const success = await actions.rename(presetId, 'New Name');
- *
- * // Delete preset
- * const deleted = await actions.delete(presetId);
- *
- * // Manual reload
- * await actions.load();
- * ```
- *
- * @param controller - Backend controller for API communication
- * @param firebaseUid - User identifier for backend operations
- * @param options - Configuration options
- * @returns Object with presets, info, and actions
- */
-export declare function usePreset(controller: Controller | null, firebaseUid: string, options?: PresetOptions): UsePresetReturn;

package/dist/hooks/usePreset.js

@@ -1,344 +0,0 @@
-import { useState, useCallback, useEffect, useRef, useMemo } from 'react';
-/**
- * Hook for managing presets with backend communication through Controller.
- *
- * **Key Features:**
- * - **Backend Communication**: All operations go through the provided Controller
- * - **Local State Management**: Maintains local preset list for UI performance
- * - **CRUD Operations**: Create, rename, delete, and list presets
- * - **Error Handling**: Provides error states for failed operations
- * - **Auto-loading**: Optional automatic preset loading on initialization
- *
- * **Typical Usage:**
- * ```typescript
- * const { presets, actions, info } = usePreset(controller, firebaseUid, { autoLoad: true });
- *
- * // Create preset
- * const newPreset = await actions.create('My Preset', adjustmentState);
- *
- * // Rename preset
- * const success = await actions.rename(presetId, 'New Name');
- *
- * // Delete preset
- * const deleted = await actions.delete(presetId);
- *
- * // Manual reload
- * await actions.load();
- * ```
- *
- * @param controller - Backend controller for API communication
- * @param firebaseUid - User identifier for backend operations
- * @param options - Configuration options
- * @returns Object with presets, info, and actions
- */
-export function usePreset(controller, firebaseUid, options = {}) {
-    // Memoize options to prevent re-renders when object is recreated with same values
-    const memoizedOptions = useMemo(() => ({
-        devWarnings: options.devWarnings ?? false,
-        autoLoad: options.autoLoad ?? false
-    }), [options.devWarnings, options.autoLoad]);
-    // Core state
-    const [presets, setPresets] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [isInitialized, setIsInitialized] = useState(false);
-    // Helper function to log debug messages - memoized to prevent re-renders
-    const debugLog = useCallback((message, data) => {
-        if (memoizedOptions.devWarnings) {
-            console.log(`[usePreset] ${message}`, data || '');
-        }
-    }, [memoizedOptions.devWarnings]);
-    // Stable references for controller and firebaseUid to detect actual changes
-    const stableControllerRef = useRef(controller);
-    const stableFirebaseUidRef = useRef(firebaseUid);
-    const prevStableControllerRef = useRef(controller);
-    const prevStableFirebaseUidRef = useRef(firebaseUid);
-    // Update refs only when values actually change (by reference)
-    if (stableControllerRef.current !== controller) {
-        stableControllerRef.current = controller;
-    }
-    if (stableFirebaseUidRef.current !== firebaseUid) {
-        stableFirebaseUidRef.current = firebaseUid;
-    }
-    // Helper function to handle errors
-    const handleError = useCallback((operation, error) => {
-        const errorMessage = `Failed to ${operation}: ${error instanceof Error ? error.message : String(error)}`;
-        setError(errorMessage);
-        debugLog(`Error in ${operation}`, error);
-        return false;
-    }, [debugLog]);
-    // Load presets from backend
-    const load = useCallback(async () => {
-        console.log("Load Presets Get Function Called");
-        if (!stableControllerRef.current || !stableFirebaseUidRef.current) {
-            debugLog('Load skipped: missing controller or firebaseUid');
-            return;
-        }
-        setIsLoading(true);
-        setError(null);
-        try {
-            debugLog('Loading presets from backend...');
-            const loadedPresets = await stableControllerRef.current.getPresets(stableFirebaseUidRef.current);
-            // Ensure we always have an array
-            const presetsArray = Array.isArray(loadedPresets) ? loadedPresets : [];
-            setPresets(presetsArray);
-            setIsInitialized(true);
-            debugLog('Presets loaded successfully', { count: presetsArray.length });
-        }
-        catch (err) {
-            handleError('load presets', err);
-            setPresets([]); // Clear presets on error
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [debugLog, handleError]);
-    // Fire-and-forget version of load for internal use
-    const loadInBackground = useCallback(() => {
-        if (!stableControllerRef.current || !stableFirebaseUidRef.current) {
-            debugLog('Background load skipped: missing controller or firebaseUid');
-            return;
-        }
-        debugLog('Background loading presets...');
-        // Don't set loading state for background operations
-        stableControllerRef.current.getPresets(stableFirebaseUidRef.current)
-            .then((loadedPresets) => {
-            // Ensure we always have an array
-            const presetsArray = Array.isArray(loadedPresets) ? loadedPresets : [];
-            setPresets(presetsArray);
-            if (!isInitialized) {
-                setIsInitialized(true);
-            }
-            debugLog('Background presets loaded successfully', { count: presetsArray.length });
-        })
-            .catch((err) => {
-            debugLog('Background load failed:', err);
-            // Don't set error state for background operations
-        });
-    }, [debugLog, isInitialized]);
-    // Create a new preset
-    const create = useCallback(async (name, settings) => {
-        console.log("Create Preset Get Function Called");
-        if (!stableControllerRef.current || !stableFirebaseUidRef.current) {
-            debugLog('Create skipped: missing controller or firebaseUid');
-            return null;
-        }
-        if (!name.trim()) {
-            setError('Preset name cannot be empty');
-            return null;
-        }
-        setIsLoading(true);
-        setError(null);
-        try {
-            debugLog('Creating preset...', { name, settings });
-            // Fire the create request but don't wait for preset data in response
-            await stableControllerRef.current.createPreset(stableFirebaseUidRef.current, name, settings);
-            debugLog('Preset creation request completed');
-            const newPreset = {
-                id: `temp-${Date.now()}`, // Use a temporary ID
-                name: name,
-                is_default: false,
-                temperature: settings.tempScore,
-                tint: settings.tintScore,
-                saturation: settings.saturationScore,
-                vibrance: settings.vibranceScore,
-                exposure: settings.exposureScore,
-                contrast: settings.contrastScore,
-                highlights: settings.highlightsScore,
-                shadows: settings.shadowsScore,
-                whites: settings.whitesScore,
-                blacks: settings.blacksScore,
-                clarity: settings.clarityScore,
-                sharpness: settings.sharpnessScore,
-            };
-            // Add the new preset to the local state immediately
-            setPresets(prev => [...prev, newPreset]);
-            // Fire and forget: Schedule a delayed refresh to get updated preset list
-            setTimeout(() => {
-                debugLog('Refreshing presets after create (fire and forget)');
-                loadInBackground();
-            }, 500); // 500ms delay to allow backend processing
-            // Return a minimal success indicator since we don't have the actual preset data
-            // return { id: 'pending', name, is_default: false } as Preset;
-            return newPreset;
-        }
-        catch (err) {
-            handleError('create preset', err);
-            return null;
-        }
-        finally {
-            setIsLoading(false);
-        }
-        // loadInBackground
-    }, [presets, debugLog, handleError, loadInBackground]);
-    // Rename an existing preset
-    const rename = useCallback(async (presetId, newName) => {
-        if (!stableControllerRef.current || !stableFirebaseUidRef.current) {
-            debugLog('Rename skipped: missing controller or firebaseUid');
-            return false;
-        }
-        if (!newName.trim()) {
-            setError('Preset name cannot be empty');
-            return false;
-        }
-        const existingPreset = Array.isArray(presets) ? presets.find(p => p.id === presetId) : null;
-        if (!existingPreset) {
-            setError('Preset not found');
-            return false;
-        }
-        // Check for duplicate names (excluding the current preset)
-        if (Array.isArray(presets) && presets.some(p => p.id !== presetId && p.name.toLowerCase() === newName.toLowerCase())) {
-            setError('A preset with this name already exists');
-            return false;
-        }
-        setIsLoading(true);
-        setError(null);
-        try {
-            debugLog('Renaming preset...', { presetId, oldName: existingPreset.name, newName });
-            const updatedPreset = { ...existingPreset, name: newName };
-            await stableControllerRef.current.updatePreset(stableFirebaseUidRef.current, updatedPreset);
-            // Update local state
-            setPresets(prev => prev.map(p => p.id === presetId ? updatedPreset : p));
-            debugLog('Preset renamed successfully');
-            return true;
-        }
-        catch (err) {
-            handleError('rename preset', err);
-            return false;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [presets, debugLog, handleError]);
-    // Delete a preset
-    const deletePreset = useCallback(async (presetId) => {
-        console.log("Delete Presets Get Function Called");
-        if (!stableControllerRef.current || !stableFirebaseUidRef.current) {
-            debugLog('Delete skipped: missing controller or firebaseUid');
-            return false;
-        }
-        const existingPreset = Array.isArray(presets) ? presets.find(p => p.id === presetId) : null;
-        if (!existingPreset) {
-            setError('Preset not found');
-            return false;
-        }
-        setIsLoading(true);
-        setError(null);
-        try {
-            debugLog('Deleting preset...', { presetId, name: existingPreset.name });
-            await stableControllerRef.current.deletePreset(stableFirebaseUidRef.current, presetId);
-            // Remove from local state
-            setPresets(prev => prev.filter(p => p.id !== presetId));
-            debugLog('Preset deleted successfully');
-            return true;
-        }
-        catch (err) {
-            handleError('delete preset', err);
-            return false;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [presets, debugLog, handleError]);
-    // Find preset that matches the given adjustment state
-    const findByAdjustments = useCallback((adjustments) => {
-        // Helper function to normalize adjustment values (treat null/undefined as 0)
-        const normalizeValue = (value) => {
-            return value ?? 0;
-        };
-        // Helper function to convert Preset to AdjustmentState for comparison
-        const presetToAdjustmentState = (preset) => {
-            return {
-                tempScore: normalizeValue(preset.temperature),
-                tintScore: normalizeValue(preset.tint),
-                vibranceScore: normalizeValue(preset.vibrance),
-                saturationScore: normalizeValue(preset.saturation),
-                exposureScore: normalizeValue(preset.exposure),
-                highlightsScore: normalizeValue(preset.highlights),
-                shadowsScore: normalizeValue(preset.shadows),
-                whitesScore: normalizeValue(preset.whites),
-                blacksScore: normalizeValue(preset.blacks),
-                contrastScore: normalizeValue(preset.contrast),
-                clarityScore: normalizeValue(preset.clarity),
-                sharpnessScore: normalizeValue(preset.sharpness)
-            };
-        };
-        // Helper function to compare two adjustment states
-        const adjustmentsMatch = (presetSettings, current) => {
-            const keys = [
-                'tempScore', 'tintScore', 'vibranceScore', 'saturationScore',
-                'exposureScore', 'highlightsScore', 'shadowsScore', 'whitesScore',
-                'blacksScore', 'contrastScore', 'clarityScore', 'sharpnessScore'
-            ];
-            return keys.every(key => normalizeValue(presetSettings[key]) === normalizeValue(current[key]));
-        };
-        debugLog('Finding preset by adjustments...', adjustments);
-        // Find preset that matches the current adjustments
-        const matchingPreset = Array.isArray(presets) ? presets.find(preset => {
-            const presetAdjustments = presetToAdjustmentState(preset);
-            return adjustmentsMatch(presetAdjustments, adjustments);
-        }) : null;
-        if (matchingPreset) {
-            debugLog('Found matching preset:', matchingPreset);
-            return matchingPreset;
-        }
-        else {
-            debugLog('No matching preset found');
-            return null;
-        }
-    }, [presets, debugLog]);
-    // Auto-load presets on initialization or when firebaseUid becomes available
-    useEffect(() => {
-        const hasValidCredentials = stableControllerRef.current && stableFirebaseUidRef.current;
-        const shouldAutoLoad = memoizedOptions.autoLoad && hasValidCredentials;
-        if (shouldAutoLoad && !isInitialized) {
-            debugLog('Auto-loading presets on initialization...');
-            load();
-        }
-        else if (shouldAutoLoad && isInitialized) {
-            // If we're already initialized but firebaseUid changed to a new valid value, reload
-            const firebaseUidChanged = prevStableFirebaseUidRef.current !== stableFirebaseUidRef.current;
-            if (firebaseUidChanged && stableFirebaseUidRef.current) {
-                debugLog('Auto-loading presets due to firebaseUid change...');
-                load();
-            }
-        }
-    }, [memoizedOptions.autoLoad, stableControllerRef.current, stableFirebaseUidRef.current, isInitialized, load]);
-    // Clear state when controller or firebaseUid changes - but only when they actually change
-    useEffect(() => {
-        const controllerChanged = prevStableControllerRef.current !== stableControllerRef.current;
-        const firebaseUidChanged = prevStableFirebaseUidRef.current !== stableFirebaseUidRef.current;
-        if ((controllerChanged || firebaseUidChanged) && isInitialized) {
-            debugLog('Controller or firebaseUid changed, clearing state');
-            setError(null);
-            // Only reset initialization if firebaseUid became null/empty
-            if (firebaseUidChanged && !stableFirebaseUidRef.current) {
-                setIsInitialized(false);
-                setPresets([]); // Clear presets when user changes
-            }
-        }
-        prevStableControllerRef.current = stableControllerRef.current;
-        prevStableFirebaseUidRef.current = stableFirebaseUidRef.current;
-    }, [stableControllerRef.current, stableFirebaseUidRef.current, isInitialized, debugLog]);
-    // Preset info object - memoized to prevent re-renders
-    const info = useMemo(() => ({
-        isLoading,
-        error,
-        count: Array.isArray(presets) ? presets.length : 0,
-        isInitialized
-    }), [isLoading, error, presets, isInitialized]);
-    // Actions object - memoized to prevent re-renders when functions don't change
-    const actions = useMemo(() => ({
-        create,
-        rename,
-        delete: deletePreset,
-        load,
-        findByAdjustments
-    }), [create, rename, deletePreset, load, findByAdjustments]);
-    // Return object - memoized to prevent re-renders when values don't change
-    return useMemo(() => ({
-        presets,
-        info,
-        actions
-    }), [presets, info, actions]);
-}

package/dist/index.d.ts

@@ -1,41 +0,0 @@
-export { HonchoEditorBulkDemo } from './hooks/demo/HonchoEditorBulkDemo';
-export { HonchoEditorSingleCleanDemo } from './hooks/demo/HonchoEditorSingleCleanDemo';
-export { useHonchoEditorSingle } from './hooks/editor/useHonchoEditorSingle';
-export { useHonchoEditorBulk } from './hooks/editor/useHonchoEditorBulk';
-export type { Controller, AdjustmentState, Preset, ImageItem, ColorAdjustment, CreateEditorTaskRequest, EditorHistoryEntry, GetGalleryUpdateTimestampResponse, GetHistoryResponse, } from './hooks/editor/type';
-export type { PhotoData } from './hooks/editor/useHonchoEditorBulk';
-export type { Gallery, Content } from './hooks/editor/type';
-export { default as HHeaderEditor } from './components/editor/HHeaderEditor';
-export { default as HFooter } from './components/editor/HFooter';
-export { default as HAccordionColorAdjustment } from './components/editor/HAccordionColorAdjustment';
-export { default as HAccordionPreset } from './components/editor/HAccordionPreset';
-export { HBaseDialog, HDialogForPreset } from './components/editor/HDialogBox';
-export { HDialogCopy, HDialogPreset } from './components/editor/HDialogCopy';
-export { default as HImageEditorMobile } from './components/editor/HImageEditorMobile';
-export { default as HImageEditorDesktop } from './components/editor/HImageEditorDekstop';
-export { default as HImageEditorBulkDekstop } from './components/editor/HImageEditorBulkDekstop';
-export { default as HImageEditorBulkMobile } from './components/editor/HImageEditorBulkMobile';
-export { default as HBulkAccordionColorAdjustment } from './components/editor/HBulkAccordionColorAdjustment';
-export { default as HBulkPreset } from './components/editor/HBulkPreset';
-export { default as HModalEditorDekstop } from './components/editor/HModalEditorDekstop';
-export { HTextField, HTextFieldRename } from './components/editor/HTextField';
-export { default as HWatermarkView } from './components/editor/HWatermarkView';
-export { default as HModalMobile } from './components/editor/HModalMobile';
-export { default as HPresetOptionsMenu } from './components/editor/HPresetOptionMenu';
-export { HAlertInternetBox, HAlertCopyBox, HAlertInternetConnectionBox, HAlertPresetSave } from './components/editor/HAlertBox';
-export { AlbumImageGallery } from './components/editor/GalleryAlbum/AlbumImageGallery';
-export { default as GalleryImageItem } from './components/editor/GalleryAlbum/ImageItem';
-export { EditorProvider, useEditorContext } from './lib/context/EditorContext';
-export { useImageProcessor } from './lib/hooks/useImageProcessor';
-export { useEditorHeadless } from './lib/hooks/useEditorHeadless';
-export { ImageSize, HonchoEditor, AdjustmentValues, AdjustmentRange, AdjustmentRanges } from './lib/editor/honcho-editor';
-export { default as HPresetDeleteDialog } from './components/editor/HPresetDelete';
-export { default as HModalDialog } from './components/modal/HModalDialog';
-export { default as HModalRename } from './components/modal/HModalRename';
-export { useAdjustmentHistory, type UseAdjustmentHistoryReturn, type HistoryInfo, type HistoryActions, type HistoryConfig } from './hooks/useAdjustmentHistory';
-export { useAdjustmentHistoryBatch, type UseAdjustmentHistoryBatchReturn, type BatchAdjustmentState, type ImageAdjustmentConfig, type BatchHistoryInfo, type BatchHistoryActions, type BatchHistoryConfig } from './hooks/useAdjustmentHistoryBatch';
-export { usePreset, type UsePresetReturn, type PresetInfo, type PresetActions, type PresetOptions } from './hooks/usePreset';
-export { usePaging, type UsePagingReturn, type PagingInfo, type PagingActions, type PagingOptions } from './hooks/usePaging';
-export { default as useColors } from './themes/colors';
-export { default as useHonchoTypography } from './themes/honchoTheme';
-export { default as useIsMobile } from './utils/isMobile';

package/dist/index.js

@@ -1,44 +0,0 @@
-// START: delete later
-export { HonchoEditorBulkDemo } from './hooks/demo/HonchoEditorBulkDemo';
-export { HonchoEditorSingleCleanDemo } from './hooks/demo/HonchoEditorSingleCleanDemo';
-// END
-export { useHonchoEditorSingle } from './hooks/editor/useHonchoEditorSingle';
-export { useHonchoEditorBulk } from './hooks/editor/useHonchoEditorBulk';
-export { default as HHeaderEditor } from './components/editor/HHeaderEditor';
-export { default as HFooter } from './components/editor/HFooter';
-export { default as HAccordionColorAdjustment } from './components/editor/HAccordionColorAdjustment';
-export { default as HAccordionPreset } from './components/editor/HAccordionPreset';
-export { HBaseDialog, HDialogForPreset } from './components/editor/HDialogBox';
-export { HDialogCopy, HDialogPreset } from './components/editor/HDialogCopy';
-export { default as HImageEditorMobile } from './components/editor/HImageEditorMobile';
-export { default as HImageEditorDesktop } from './components/editor/HImageEditorDekstop';
-export { default as HImageEditorBulkDekstop } from './components/editor/HImageEditorBulkDekstop';
-export { default as HImageEditorBulkMobile } from './components/editor/HImageEditorBulkMobile';
-export { default as HBulkAccordionColorAdjustment } from './components/editor/HBulkAccordionColorAdjustment';
-export { default as HBulkPreset } from './components/editor/HBulkPreset';
-export { default as HModalEditorDekstop } from './components/editor/HModalEditorDekstop';
-export { HTextField, HTextFieldRename } from './components/editor/HTextField';
-export { default as HWatermarkView } from './components/editor/HWatermarkView';
-export { default as HModalMobile } from './components/editor/HModalMobile';
-export { default as HPresetOptionsMenu } from './components/editor/HPresetOptionMenu';
-export { HAlertInternetBox, HAlertCopyBox, HAlertInternetConnectionBox, HAlertPresetSave } from './components/editor/HAlertBox';
-export { AlbumImageGallery } from './components/editor/GalleryAlbum/AlbumImageGallery';
-export { default as GalleryImageItem } from './components/editor/GalleryAlbum/ImageItem';
-export { EditorProvider, useEditorContext } from './lib/context/EditorContext';
-export { useImageProcessor } from './lib/hooks/useImageProcessor';
-export { useEditorHeadless } from './lib/hooks/useEditorHeadless';
-export { HonchoEditor } from './lib/editor/honcho-editor';
-export { default as HPresetDeleteDialog } from './components/editor/HPresetDelete';
-export { default as HModalDialog } from './components/modal/HModalDialog';
-export { default as HModalRename } from './components/modal/HModalRename';
-// --- History Hooks ---
-export { useAdjustmentHistory } from './hooks/useAdjustmentHistory';
-export { useAdjustmentHistoryBatch } from './hooks/useAdjustmentHistoryBatch';
-// --- Preset Hook ---
-export { usePreset } from './hooks/usePreset';
-// --- Paging Hook ---
-export { usePaging } from './hooks/usePaging';
-// --- Theme & Utils ---
-export { default as useColors } from './themes/colors';
-export { default as useHonchoTypography } from './themes/honchoTheme';
-export { default as useIsMobile } from './utils/isMobile';

package/dist/lib/context/EditorContext.d.ts

@@ -1,28 +0,0 @@
-import React from 'react';
-import { EditorProcessingService } from '../context/EditorProcessingService';
-import HonchoEditor from "../editor/honcho-editor";
-interface EditorContextValue {
-    isReady: boolean;
-    error: Error | null;
-    processingService: EditorProcessingService;
-    queueStatus: {
-        queueLength: number;
-        isProcessing: boolean;
-        hasProcessor: boolean;
-    };
-    editor: HonchoEditor | null;
-    loadImageFromUrl: ((url: string) => Promise<{
-        width: number;
-        height: number;
-    }>) | null;
-}
-interface EditorProviderProps {
-    children: React.ReactNode;
-    /** URL to the honcho-photo-editor.js script (defaults to '/honcho-photo-editor.js') */
-    scriptUrl?: string;
-    /** URL to the honcho-photo-editor.wasm file (defaults to '/honcho-photo-editor.wasm') */
-    wasmUrl?: string;
-}
-export declare const EditorProvider: React.FC<EditorProviderProps>;
-export declare const useEditorContext: () => EditorContextValue;
-export {};

package/dist/lib/context/EditorContext.js

@@ -1,60 +0,0 @@
-'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useState } from 'react';
-import { useEditorHeadless } from '../hooks/useEditorHeadless';
-import { EditorProcessingService } from '../context/EditorProcessingService';
-const EditorContext = createContext(null);
-export const EditorProvider = ({ children, scriptUrl = '/honcho-photo-editor.js', wasmUrl = '/honcho-photo-editor.wasm' }) => {
-    // Single editor instance for the entire app
-    const { editor, isReady, error, processImage, loadImageFromUrl } = useEditorHeadless({ scriptUrl, wasmUrl });
-    // Single processing service instance
-    const [processingService] = useState(() => new EditorProcessingService());
-    const [queueStatus, setQueueStatus] = useState(processingService.getQueueStatus());
-    // Connect the editor to the processing service when ready
-    useEffect(() => {
-        if (isReady && processImage) {
-            console.debug('Connecting editor to processing service - editor ready:', isReady);
-            processingService.setProcessor(processImage);
-        }
-        else {
-            console.debug('Editor not ready yet - isReady:', isReady, 'processImage:', !!processImage);
-        }
-    }, [isReady, processImage, processingService]);
-    // Update queue status periodically - now event-driven instead of polling
-    useEffect(() => {
-        const updateStatus = () => {
-            setQueueStatus(processingService.getQueueStatus());
-        };
-        // Add listener for immediate updates
-        processingService.addStatusChangeListener(updateStatus);
-        // Optional: Keep a fallback interval for safety (much less frequent)
-        const interval = setInterval(updateStatus, 5000); // 5 seconds instead of 1
-        return () => {
-            processingService.removeStatusChangeListener(updateStatus);
-            clearInterval(interval);
-        };
-    }, [processingService]);
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            processingService.cleanup(); // Use new cleanup method
-        };
-    }, [processingService]);
-    const contextValue = {
-        isReady,
-        error,
-        processingService,
-        queueStatus,
-        editor: editor,
-        loadImageFromUrl
-    };
-    return (_jsx(EditorContext.Provider, { value: contextValue, children: children }));
-};
-// Custom hook to use the editor context
-export const useEditorContext = () => {
-    const context = useContext(EditorContext);
-    if (!context) {
-        throw new Error('useEditorContext must be used within an EditorProvider');
-    }
-    return context;
-};

package/dist/lib/context/EditorProcessingService.d.ts

@@ -1,36 +0,0 @@
-import type { AdjustmentValues } from '../editor/honcho-editor';
-export interface EditorTask {
-    id: string;
-    path: string;
-    frame: string | null;
-    adjustments?: Partial<AdjustmentValues>;
-    priority?: number;
-    abortSignal?: AbortSignal;
-}
-export interface EditorResponse {
-    id: string;
-    path: string;
-}
-export declare class EditorProcessingService {
-    private processingQueue;
-    private isProcessing;
-    private processImage?;
-    private pendingProcessingTimeout?;
-    private statusChangeListeners;
-    constructor();
-    setProcessor(processImage: (task: EditorTask) => Promise<EditorResponse>): void;
-    addStatusChangeListener(listener: () => void): void;
-    removeStatusChangeListener(listener: () => void): void;
-    private notifyStatusChange;
-    requestProcessing(task: EditorTask): Promise<EditorResponse>;
-    private scheduleProcessing;
-    private processQueue;
-    private removeFromQueue;
-    getQueueStatus(): {
-        queueLength: number;
-        isProcessing: boolean;
-        hasProcessor: boolean;
-    };
-    clearQueue(): void;
-    cleanup(): void;
-}