@finsweet/webflow-apps-utils 1.0.1 → 1.0.3

package/dist/providers/configuratorUtils.js

@@ -0,0 +1,219 @@
+/**
+ * Create default configurator state
+ */
+export function createDefaultConfiguratorState() {
+    return {
+        configurator: null,
+        configuratorCache: null,
+        hasChanged: false,
+        watchOptions: {
+            watchAll: true,
+            watchKeys: [],
+            debounceMs: 100
+        }
+    };
+}
+// Cache for deep comparison results to avoid repeated expensive operations
+const comparisonCache = new Map();
+const CACHE_TTL = 1000;
+/**
+ * Optimized deep compare with caching and early returns
+ */
+function deepEqual(obj1, obj2, maxDepth = 10) {
+    if (obj1 === obj2)
+        return true;
+    if (maxDepth <= 0)
+        return obj1 === obj2;
+    if (obj1 == null || obj2 == null)
+        return obj1 === obj2;
+    const type1 = typeof obj1;
+    const type2 = typeof obj2;
+    if (type1 !== type2)
+        return false;
+    if (type1 !== 'object')
+        return obj1 === obj2;
+    const isArray1 = Array.isArray(obj1);
+    const isArray2 = Array.isArray(obj2);
+    if (isArray1 !== isArray2)
+        return false;
+    if (isArray1) {
+        if (obj1.length !== obj2.length)
+            return false;
+        for (let i = 0; i < obj1.length; i++) {
+            if (!deepEqual(obj1[i], obj2[i], maxDepth - 1))
+                return false;
+        }
+        return true;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    keys1.sort();
+    keys2.sort();
+    for (let i = 0; i < keys1.length; i++) {
+        if (keys1[i] !== keys2[i])
+            return false;
+    }
+    for (const key of keys1) {
+        if (!deepEqual(obj1[key], obj2[key], maxDepth - 1))
+            return false;
+    }
+    return true;
+}
+/**
+ * Fast shallow comparison for primitive values and first-level objects
+ */
+function shallowCompare(obj1, obj2) {
+    if (obj1 === obj2)
+        return true;
+    if (obj1 == null || obj2 == null)
+        return obj1 === obj2;
+    if (typeof obj1 !== 'object' || typeof obj2 !== 'object')
+        return obj1 === obj2;
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    for (const key of keys1) {
+        if (obj1[key] !== obj2[key])
+            return false;
+    }
+    return true;
+}
+/**
+ * Deep compare two objects with performance optimizations
+ */
+export function deepCompare(obj1, obj2) {
+    if (shallowCompare(obj1, obj2))
+        return true;
+    const cacheKey = JSON.stringify([obj1, obj2]);
+    const cached = comparisonCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        return cached.result;
+    }
+    const result = deepEqual(obj1, obj2, 5);
+    comparisonCache.set(cacheKey, { result, timestamp: Date.now() });
+    // Clean old cache entries periodically
+    if (comparisonCache.size > 100) {
+        const now = Date.now();
+        for (const [key, value] of comparisonCache.entries()) {
+            if (now - value.timestamp > CACHE_TTL) {
+                comparisonCache.delete(key);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Compare specific keys of two objects with optimization
+ */
+export function compareKeys(obj1, obj2, keys) {
+    if (!obj1 && !obj2)
+        return true;
+    if (!obj1 || !obj2)
+        return false;
+    if (keys.length === 0)
+        return true;
+    if (keys.length === 1) {
+        const key = keys[0];
+        return obj1[key] === obj2[key] || deepCompare(obj1[key], obj2[key]);
+    }
+    for (const key of keys) {
+        const val1 = obj1[key];
+        const val2 = obj2[key];
+        if (val1 === val2)
+            continue;
+        if (!deepCompare(val1, val2)) {
+            return false;
+        }
+    }
+    return true;
+}
+// Debounce storage
+const debounceTimers = new Map();
+/**
+ * Determine if configurator has changed with performance optimization
+ */
+export function hasConfiguratorChanged(configurator, configuratorCache, watchOptions) {
+    if (!configurator && !configuratorCache)
+        return false;
+    if (!configurator || !configuratorCache)
+        return true;
+    if (watchOptions.watchAll) {
+        if (shallowCompare(configurator, configuratorCache))
+            return false;
+        return !deepCompare(configurator, configuratorCache);
+    }
+    if (watchOptions.watchKeys && watchOptions.watchKeys.length > 0) {
+        return !compareKeys(configurator, configuratorCache, watchOptions.watchKeys);
+    }
+    return !shallowCompare(configurator, configuratorCache);
+}
+/**
+ * Create a debounced function for configurator updates
+ */
+export function createDebouncedUpdate(fn, delay) {
+    const key = fn.toString();
+    return ((...args) => {
+        const existingTimer = debounceTimers.get(key);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(() => {
+            debounceTimers.delete(key);
+            fn(...args);
+        }, delay);
+        debounceTimers.set(key, timer);
+    });
+}
+/**
+ * Extract specific keys from an object
+ */
+export function extractKeys(obj, keys) {
+    if (!obj || keys.length === 0)
+        return null;
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/**
+ * Get all keys from an object (for watchAll mode)
+ */
+export function getAllKeys(obj) {
+    if (!obj)
+        return [];
+    return Object.keys(obj);
+}
+/**
+ * Validate watch options
+ */
+export function validateWatchOptions(options) {
+    const validated = {
+        watchAll: options.watchAll ?? true,
+        watchKeys: options.watchKeys ?? [],
+        debounceMs: Math.max(options.debounceMs ?? 50, 16)
+    };
+    if (!validated.watchAll && (!validated.watchKeys || validated.watchKeys.length === 0)) {
+        validated.watchAll = true;
+    }
+    return validated;
+}
+/**
+ * Create a snapshot of configurator state for comparison
+ */
+export function createConfiguratorSnapshot(configurator, watchOptions) {
+    if (!configurator)
+        return null;
+    if (watchOptions.watchAll) {
+        return { ...configurator };
+    }
+    if (watchOptions.watchKeys && watchOptions.watchKeys.length > 0) {
+        return extractKeys(configurator, watchOptions.watchKeys);
+    }
+    return { ...configurator };
+}

package/dist/providers/globalContext.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { AppContextData, ConfiguratorWatchOptions, ContextOperations, DataContextData, FormContextData, GlobalContextOperations } from './types';
+export declare function createGlobalContext(initialContexts?: Record<string, unknown>, debug?: boolean): GlobalContextOperations;
+export declare function setGlobalContext(context: ReturnType<typeof createGlobalContext>): GlobalContextOperations;
+export declare function getGlobalContext(): ReturnType<typeof createGlobalContext>;
+export declare function useContext<T = unknown>(key: string): ContextOperations<T>;
+export declare function useFormContext(): ContextOperations<FormContextData>;
+export declare function useAppContext<TConfigurator = Record<string, unknown>>(): ContextOperations<AppContextData<TConfigurator>>;
+export declare function useDataContext<TData = Record<string, unknown>>(): ContextOperations<DataContextData<TData>>;
+export declare function useConfiguratorContext<TConfigurator = Record<string, unknown>>(): {
+    readonly configurator: TConfigurator | null;
+    readonly configuratorCache: TConfigurator | null;
+    readonly hasChanged: boolean;
+    readonly watchOptions: ConfiguratorWatchOptions;
+    setConfigurator(configurator: TConfigurator | null, watchOptions?: Partial<ConfiguratorWatchOptions>): void;
+    setConfiguratorCache(configuratorCache: TConfigurator | null): void;
+    saveToCache(): void;
+    updateWatchOptions(watchOptions: Partial<ConfiguratorWatchOptions>): void;
+};

package/dist/providers/globalContext.svelte.js

@@ -0,0 +1,439 @@
+import { getContext, setContext } from 'svelte';
+import { createDebouncedUpdate, hasConfiguratorChanged, validateWatchOptions } from './configuratorUtils';
+const GLOBAL_CONTEXT_KEY = Symbol('global-context');
+export function createGlobalContext(initialContexts = {}, debug = false) {
+    // Context storage
+    const contexts = $state(new Map());
+    const activeContexts = $state(new Set());
+    const eventListeners = new Map();
+    // Performance optimization: Track last configurator state to avoid unnecessary updates
+    let lastConfiguratorState = null;
+    let lastConfiguratorHash = null;
+    // Initialize contexts
+    for (const [key, value] of Object.entries(initialContexts)) {
+        contexts.set(key, {
+            data: value,
+            updatedAt: Date.now(),
+            version: 1
+        });
+        activeContexts.add(key);
+    }
+    // Debug logging with throttling
+    let debugLogCount = 0;
+    const MAX_DEBUG_LOGS = 100;
+    function debugLog(message, data) {
+        if (debug && debugLogCount < MAX_DEBUG_LOGS) {
+            console.log(`[GlobalContext] ${message}`, data);
+            debugLogCount++;
+            if (debugLogCount >= MAX_DEBUG_LOGS) {
+                setTimeout(() => {
+                    debugLogCount = 0;
+                }, 5000);
+            }
+        }
+    }
+    // Event emission with batching
+    const eventQueue = [];
+    let eventBatchTimeout = null;
+    function emitEvent(event) {
+        eventQueue.push(event);
+        if (!eventBatchTimeout) {
+            eventBatchTimeout = setTimeout(() => {
+                flushEventQueue();
+                eventBatchTimeout = null;
+            }, 16);
+        }
+    }
+    function flushEventQueue() {
+        const events = [...eventQueue];
+        eventQueue.length = 0;
+        for (const event of events) {
+            debugLog('Event emitted', event);
+            // Emit to specific context listeners
+            if ('contextKey' in event && event.contextKey) {
+                const listeners = eventListeners.get(event.contextKey);
+                if (listeners) {
+                    for (const listener of listeners) {
+                        try {
+                            listener(event);
+                        }
+                        catch (error) {
+                            console.warn('Event listener error:', error);
+                        }
+                    }
+                }
+            }
+            // Emit to global listeners
+            const globalListeners = eventListeners.get('*');
+            if (globalListeners) {
+                for (const listener of globalListeners) {
+                    try {
+                        listener(event);
+                    }
+                    catch (error) {
+                        console.warn('Global event listener error:', error);
+                    }
+                }
+            }
+        }
+    }
+    // Helper methods for configurator handling
+    function isConfiguratorUpdate(data) {
+        return (typeof data === 'object' &&
+            data !== null &&
+            'configurator' in data &&
+            typeof data.configurator === 'object');
+    }
+    // Fast hash function for configurator state comparison
+    function hashObject(obj) {
+        if (!obj)
+            return 'null';
+        if (typeof obj !== 'object')
+            return String(obj);
+        try {
+            const str = JSON.stringify(obj, null, 0);
+            if (str.length > 1000) {
+                return (Object.keys(obj).sort().join(',') +
+                    ':' +
+                    Object.values(obj)
+                        .filter((v) => typeof v !== 'object')
+                        .join(','));
+            }
+            return str;
+        }
+        catch {
+            return Object.keys(obj).sort().join(',');
+        }
+    }
+    // Debounced configurator update handler
+    const debouncedConfiguratorUpdate = createDebouncedUpdate((appData) => {
+        if (appData.configurator) {
+            // Validate and set watch options
+            appData.configurator.watchOptions = validateWatchOptions(appData.configurator.watchOptions || { watchAll: true, debounceMs: 50 });
+            // Compute hasChanged based on configurator and cache comparison
+            const hasChanged = hasConfiguratorChanged(appData.configurator.configurator, appData.configurator.configuratorCache, appData.configurator.watchOptions);
+            // Update hasChanged only if it's actually different
+            if (appData.configurator.hasChanged !== hasChanged) {
+                appData.configurator.hasChanged = hasChanged;
+                debugLog('Configurator hasChanged updated', {
+                    hasChanged,
+                    configurator: appData.configurator.configurator,
+                    cache: appData.configurator.configuratorCache,
+                    watchOptions: appData.configurator.watchOptions
+                });
+            }
+        }
+    }, 50);
+    function handleConfiguratorUpdate(newData, previousData) {
+        const appData = newData;
+        if (appData.configurator) {
+            // Quick hash check to avoid unnecessary processing
+            const currentHash = hashObject(appData.configurator.configurator);
+            if (currentHash === lastConfiguratorHash) {
+                return;
+            }
+            lastConfiguratorHash = currentHash;
+            lastConfiguratorState = appData.configurator.configurator;
+            // Use debounced update for configurator changes
+            debouncedConfiguratorUpdate(appData);
+        }
+    }
+    // Enhanced context operations with configurator support
+    function createContextOperations(key) {
+        const operations = {
+            get() {
+                const context = contexts.get(key);
+                return context?.data;
+            },
+            set(data) {
+                const currentContext = contexts.get(key);
+                const previousData = currentContext?.data;
+                const newData = previousData ? { ...previousData, ...data } : data;
+                // Handle configurator state updates with watching
+                if (key === 'app' && isConfiguratorUpdate(data)) {
+                    handleConfiguratorUpdate(newData, previousData);
+                }
+                contexts.set(key, {
+                    data: newData,
+                    updatedAt: Date.now(),
+                    version: (currentContext?.version || 0) + 1
+                });
+                activeContexts.add(key);
+                emitEvent({
+                    type: 'set',
+                    contextKey: key,
+                    data: newData,
+                    previousData,
+                    timestamp: Date.now()
+                });
+            },
+            update(updater) {
+                const currentContext = contexts.get(key);
+                const previousData = currentContext?.data;
+                const newData = updater(previousData);
+                // Handle configurator state updates with watching
+                if (key === 'app' && isConfiguratorUpdate(newData)) {
+                    handleConfiguratorUpdate(newData, previousData);
+                }
+                contexts.set(key, {
+                    data: newData,
+                    updatedAt: Date.now(),
+                    version: (currentContext?.version || 0) + 1
+                });
+                activeContexts.add(key);
+                emitEvent({
+                    type: 'update',
+                    contextKey: key,
+                    data: newData,
+                    previousData,
+                    timestamp: Date.now()
+                });
+            },
+            clear() {
+                const currentContext = contexts.get(key);
+                const previousData = currentContext?.data;
+                contexts.set(key, {
+                    data: null,
+                    updatedAt: Date.now(),
+                    version: (currentContext?.version || 0) + 1
+                });
+                emitEvent({
+                    type: 'clear',
+                    contextKey: key,
+                    data: null,
+                    previousData,
+                    timestamp: Date.now()
+                });
+            },
+            reset() {
+                const currentContext = contexts.get(key);
+                const previousData = currentContext?.data;
+                contexts.delete(key);
+                activeContexts.delete(key);
+                emitEvent({
+                    type: 'reset',
+                    contextKey: key,
+                    data: null,
+                    previousData,
+                    timestamp: Date.now()
+                });
+            },
+            subscribe(callback) {
+                const listeners = eventListeners.get(key) || new Set();
+                const wrappedCallback = (event) => {
+                    if ('contextKey' in event && event.contextKey === key) {
+                        callback(event.data);
+                    }
+                };
+                listeners.add(wrappedCallback);
+                eventListeners.set(key, listeners);
+                // Return unsubscribe function
+                return () => {
+                    listeners.delete(wrappedCallback);
+                    if (listeners.size === 0) {
+                        eventListeners.delete(key);
+                    }
+                };
+            }
+        };
+        return operations;
+    }
+    // Global operations
+    const globalOperations = {
+        getContext(key) {
+            return createContextOperations(key);
+        },
+        hasContext(key) {
+            return contexts.has(key);
+        },
+        removeContext(key) {
+            const currentContext = contexts.get(key);
+            const previousData = currentContext?.data;
+            contexts.delete(key);
+            activeContexts.delete(key);
+            emitEvent({
+                type: 'remove',
+                contextKey: key,
+                data: null,
+                previousData,
+                timestamp: Date.now()
+            });
+        },
+        clearAll() {
+            const previousState = this.getAllContexts();
+            for (const key of contexts.keys()) {
+                contexts.set(key, {
+                    data: null,
+                    updatedAt: Date.now(),
+                    version: (contexts.get(key)?.version || 0) + 1
+                });
+            }
+            emitEvent({
+                type: 'clearAll',
+                data: null,
+                previousData: previousState,
+                timestamp: Date.now()
+            });
+        },
+        resetAll() {
+            const previousState = this.getAllContexts();
+            contexts.clear();
+            activeContexts.clear();
+            emitEvent({
+                type: 'resetAll',
+                data: null,
+                previousData: previousState,
+                timestamp: Date.now()
+            });
+        },
+        resetByKey(key) {
+            const operations = this.getContext(key);
+            operations.reset();
+        },
+        getActiveContexts() {
+            return Array.from(activeContexts);
+        },
+        getAllContexts() {
+            const result = {};
+            for (const [key, context] of contexts.entries()) {
+                result[key] = context.data;
+            }
+            return result;
+        },
+        getContextMetadata(key) {
+            const context = contexts.get(key);
+            if (!context)
+                return null;
+            return {
+                updatedAt: context.updatedAt,
+                version: context.version,
+                isActive: activeContexts.has(key)
+            };
+        },
+        get state() {
+            return this.getAllContexts();
+        },
+        subscribe(callback) {
+            const listeners = eventListeners.get('*') || new Set();
+            listeners.add(callback);
+            eventListeners.set('*', listeners);
+            // Return unsubscribe function
+            return () => {
+                listeners.delete(callback);
+                if (listeners.size === 0) {
+                    eventListeners.delete('*');
+                }
+            };
+        }
+    };
+    return globalOperations;
+}
+// Context provider functions
+export function setGlobalContext(context) {
+    setContext(GLOBAL_CONTEXT_KEY, context);
+    return context;
+}
+export function getGlobalContext() {
+    const context = getContext(GLOBAL_CONTEXT_KEY);
+    if (!context) {
+        throw new Error('Global context not found. Make sure to wrap your app with GlobalProvider component.');
+    }
+    return context;
+}
+// Convenience hooks for specific contexts
+export function useContext(key) {
+    const globalContext = getGlobalContext();
+    return globalContext.getContext(key);
+}
+export function useFormContext() {
+    return useContext('form');
+}
+export function useAppContext() {
+    return useContext('app');
+}
+export function useDataContext() {
+    return useContext('data');
+}
+// Enhanced configurator hooks
+export function useConfiguratorContext() {
+    const appContext = useAppContext();
+    const configuratorOps = {
+        // Computed properties
+        get configurator() {
+            const data = appContext.get();
+            return data?.configurator?.configurator || null;
+        },
+        get configuratorCache() {
+            const data = appContext.get();
+            return data?.configurator?.configuratorCache || null;
+        },
+        get hasChanged() {
+            const data = appContext.get();
+            return data?.configurator?.hasChanged || false;
+        },
+        get watchOptions() {
+            const data = appContext.get();
+            return data?.configurator?.watchOptions || { watchAll: true, debounceMs: 50 };
+        },
+        // Optimized configurator methods
+        setConfigurator(configurator, watchOptions) {
+            const currentData = appContext.get();
+            const currentConfigurator = currentData?.configurator || {
+                configurator: null,
+                configuratorCache: null,
+                hasChanged: false,
+                watchOptions: { watchAll: true, debounceMs: 50 }
+            };
+            appContext.set({
+                configurator: {
+                    ...currentConfigurator,
+                    configurator,
+                    watchOptions: validateWatchOptions({
+                        ...currentConfigurator.watchOptions,
+                        ...watchOptions
+                    })
+                }
+            });
+        },
+        setConfiguratorCache(configuratorCache) {
+            const currentData = appContext.get();
+            const currentConfigurator = currentData?.configurator || {
+                configurator: null,
+                configuratorCache: null,
+                hasChanged: false,
+                watchOptions: { watchAll: true, debounceMs: 50 }
+            };
+            appContext.set({
+                configurator: {
+                    ...currentConfigurator,
+                    configuratorCache
+                }
+            });
+        },
+        saveToCache() {
+            const current = configuratorOps.configurator;
+            if (current) {
+                configuratorOps.setConfiguratorCache(current);
+            }
+        },
+        updateWatchOptions(watchOptions) {
+            const currentData = appContext.get();
+            const currentConfigurator = currentData?.configurator || {
+                configurator: null,
+                configuratorCache: null,
+                hasChanged: false,
+                watchOptions: { watchAll: true, debounceMs: 50 }
+            };
+            appContext.set({
+                configurator: {
+                    ...currentConfigurator,
+                    watchOptions: validateWatchOptions({
+                        ...currentConfigurator.watchOptions,
+                        ...watchOptions
+                    })
+                }
+            });
+        }
+    };
+    return configuratorOps;
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+export { default as GlobalProvider } from './GlobalProvider.svelte';
+export { createGlobalContext, setGlobalContext, getGlobalContext, useContext, useFormContext, useAppContext, useDataContext, useConfiguratorContext } from './globalContext.svelte.js';
+export type { FormContextState, AppContextState, DataContextState, ContextState, GlobalContextState, ContextOperations, GlobalContextOperations, GlobalProviderProps, ContextEvent, GlobalContextEvent, ContextKey, ContextId, ConfiguratorWatchOptions, ConfiguratorState, AppContextData, FormContextData, DataContextData } from './types.js';
+export { CONTEXT_KEYS } from './types.js';
+export { deepCompare, compareKeys, hasConfiguratorChanged, createDebouncedUpdate, extractKeys, getAllKeys, validateWatchOptions, createConfiguratorSnapshot, createDefaultConfiguratorState } from './configuratorUtils';

package/dist/providers/index.js

@@ -0,0 +1,7 @@
+// Main provider component
+export { default as GlobalProvider } from './GlobalProvider.svelte';
+// Context functions and hooks
+export { createGlobalContext, setGlobalContext, getGlobalContext, useContext, useFormContext, useAppContext, useDataContext, useConfiguratorContext } from './globalContext.svelte.js';
+export { CONTEXT_KEYS } from './types.js';
+// Configurator utilities
+export { deepCompare, compareKeys, hasConfiguratorChanged, createDebouncedUpdate, extractKeys, getAllKeys, validateWatchOptions, createConfiguratorSnapshot, createDefaultConfiguratorState } from './configuratorUtils';