@flikk/ui 1.0.0-beta.1

package/dist/utils/actionQueue.js

@@ -0,0 +1,203 @@
+import { QueueError } from './optimisticErrors.js';
+
+/**
+ * Action Queue for Offline Support
+ * Manages queued mutations when the user is offline
+ */
+/**
+ * ActionQueue class for managing offline mutations
+ */
+class ActionQueue {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        this.queue = [];
+        this.isProcessing = false;
+        this.options = {
+            maxRetries: (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 3,
+            storageKey: (_b = options.storageKey) !== null && _b !== void 0 ? _b : "flikkui-action-queue",
+            persist: (_c = options.persist) !== null && _c !== void 0 ? _c : true,
+            onActionSuccess: options.onActionSuccess,
+            onActionFailed: options.onActionFailed,
+            onQueueChange: options.onQueueChange,
+        };
+        // Load persisted queue on initialization
+        if (this.options.persist) {
+            this.loadFromStorage();
+        }
+    }
+    /**
+     * Generate a unique ID for an action
+     */
+    generateId() {
+        return `action-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    /**
+     * Save queue to localStorage
+     */
+    saveToStorage() {
+        if (!this.options.persist || typeof window === "undefined")
+            return;
+        try {
+            // We can't serialize functions, so we only persist metadata
+            const persistableQueue = this.queue.map(({ id, timestamp, retryCount, maxRetries, metadata }) => ({
+                id,
+                timestamp,
+                retryCount,
+                maxRetries,
+                metadata,
+            }));
+            localStorage.setItem(this.options.storageKey, JSON.stringify(persistableQueue));
+        }
+        catch (_a) {
+            // localStorage might be unavailable or full
+            if (process.env.NODE_ENV !== "production") {
+                console.warn("[ActionQueue] Failed to persist queue to localStorage");
+            }
+        }
+    }
+    /**
+     * Load queue from localStorage
+     * Note: Actions (functions) cannot be persisted, only metadata
+     */
+    loadFromStorage() {
+        if (typeof window === "undefined")
+            return;
+        try {
+            const stored = localStorage.getItem(this.options.storageKey);
+            if (stored) {
+                // Only load metadata - actions will need to be re-registered
+                const parsed = JSON.parse(stored);
+                if (process.env.NODE_ENV !== "production" && parsed.length > 0) {
+                    console.warn(`[ActionQueue] Found ${parsed.length} stale queued actions. Actions cannot be restored after page reload.`);
+                }
+                // Clear stale entries
+                localStorage.removeItem(this.options.storageKey);
+            }
+        }
+        catch (_a) {
+            // localStorage might be unavailable
+        }
+    }
+    /**
+     * Notify listeners of queue changes
+     */
+    notifyChange() {
+        var _a, _b;
+        this.saveToStorage();
+        (_b = (_a = this.options).onQueueChange) === null || _b === void 0 ? void 0 : _b.call(_a, this.queue);
+    }
+    /**
+     * Add an action to the queue
+     * @returns The action ID
+     */
+    add(action, options) {
+        var _a;
+        const id = this.generateId();
+        const queuedAction = {
+            id,
+            action,
+            timestamp: Date.now(),
+            retryCount: 0,
+            maxRetries: (_a = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _a !== void 0 ? _a : this.options.maxRetries,
+            metadata: {
+                label: options === null || options === void 0 ? void 0 : options.label,
+                description: options === null || options === void 0 ? void 0 : options.description,
+            },
+        };
+        this.queue.push(queuedAction);
+        this.notifyChange();
+        return id;
+    }
+    /**
+     * Remove an action from the queue
+     */
+    remove(id) {
+        const initialLength = this.queue.length;
+        this.queue = this.queue.filter((action) => action.id !== id);
+        if (this.queue.length !== initialLength) {
+            this.notifyChange();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get all queued actions
+     */
+    getAll() {
+        return [...this.queue];
+    }
+    /**
+     * Get the number of queued actions
+     */
+    get size() {
+        return this.queue.length;
+    }
+    /**
+     * Check if queue is currently processing
+     */
+    get processing() {
+        return this.isProcessing;
+    }
+    /**
+     * Clear all queued actions
+     */
+    clear() {
+        this.queue = [];
+        this.notifyChange();
+    }
+    /**
+     * Process all queued actions
+     * Call this when the user comes back online
+     */
+    async process() {
+        var _a, _b, _c, _d;
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        // Process actions in order
+        while (this.queue.length > 0) {
+            const action = this.queue[0];
+            try {
+                const result = await action.action();
+                (_b = (_a = this.options).onActionSuccess) === null || _b === void 0 ? void 0 : _b.call(_a, action, result);
+                this.queue.shift(); // Remove successful action
+                this.notifyChange();
+            }
+            catch (error) {
+                action.retryCount++;
+                if (action.retryCount >= action.maxRetries) {
+                    // Max retries reached, remove and report failure
+                    (_d = (_c = this.options).onActionFailed) === null || _d === void 0 ? void 0 : _d.call(_c, action, error instanceof Error
+                        ? error
+                        : new QueueError("Action failed after max retries", action.id, error));
+                    this.queue.shift();
+                    this.notifyChange();
+                }
+                else {
+                    // Will retry on next process() call
+                    this.notifyChange();
+                    break; // Stop processing, wait for next attempt
+                }
+            }
+        }
+        this.isProcessing = false;
+    }
+}
+/**
+ * Create an ActionQueue instance
+ */
+const createActionQueue = (options) => {
+    return new ActionQueue(options);
+};
+/**
+ * Default singleton queue for simple use cases
+ */
+let defaultQueue = null;
+const getDefaultQueue = () => {
+    if (!defaultQueue) {
+        defaultQueue = createActionQueue();
+    }
+    return defaultQueue;
+};
+
+export { ActionQueue, createActionQueue, getDefaultQueue };

package/dist/utils/calendarUtils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Calendar utility functions for event positioning, sizing, and layout calculations
+ */
+export interface CalendarEvent {
+    id: string;
+    title: string;
+    startTime: string;
+    endTime: string;
+    date: string;
+    allDay?: boolean;
+    color?: string;
+}
+export interface GridConfig {
+    startTime: string;
+    endTime: string;
+    intervalMinutes: number;
+    pixelsPerSlot: number;
+    showAllDay: boolean;
+}
+export interface EventPosition {
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+    zIndex: number;
+}
+export interface EventLayout {
+    event: CalendarEvent;
+    position: EventPosition;
+    column: number;
+    totalColumns: number;
+}
+export interface TimeSlot {
+    startTime: string;
+    endTime: string;
+    index: number;
+}
+export declare const timeToMinutes: (time: string) => number;
+export declare const minutesToTime: (minutes: number) => string;
+export declare const getEventDuration: (startTime: string, endTime: string) => number;
+export declare const getTotalTimeSlots: (gridConfig: GridConfig) => number;
+export declare const getTimeSlotIndex: (time: string, gridConfig: GridConfig) => number;
+export declare const getTimeSlotForIndex: (index: number, gridConfig: GridConfig) => TimeSlot;
+export declare const calculateEventPosition: (event: CalendarEvent, gridConfig: GridConfig, containerWidth?: number) => EventPosition;
+export declare const calculateEventHeight: (duration: number, intervalMinutes: number, pixelsPerSlot: number) => number;
+export declare const eventsOverlap: (event1: CalendarEvent, event2: CalendarEvent) => boolean;
+export declare const findOverlappingEvents: (events: CalendarEvent[], targetEvent: CalendarEvent) => CalendarEvent[];
+export declare const groupOverlappingEvents: (events: CalendarEvent[]) => CalendarEvent[][];
+export declare const resolveOverlappingEvents: (events: CalendarEvent[], gridConfig: GridConfig, containerWidth?: number) => EventLayout[];
+export declare const generateTimeGrid: (gridConfig: GridConfig) => TimeSlot[];
+export declare const filterEventsByDate: (events: CalendarEvent[], date: string) => CalendarEvent[];
+export declare const sortEventsByStartTime: (events: CalendarEvent[]) => CalendarEvent[];
+export declare const separateAllDayEvents: (events: CalendarEvent[]) => {
+    allDayEvents: CalendarEvent[];
+    timedEvents: CalendarEvent[];
+};
+export declare const isValidTimeFormat: (time: string) => boolean;
+export declare const isValidDateFormat: (date: string) => boolean;
+export declare const validateEvent: (event: CalendarEvent) => string[];
+export declare const DEFAULT_GRID_CONFIGS: Record<string, GridConfig>;

package/dist/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/utils/cn.js

@@ -0,0 +1,8 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+
+export { cn };

package/dist/utils/dateUtils.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Date and time utility functions for consistent formatting across the component library
+ */
+export type DateInput = Date | string | number;
+export interface TimestampOptions {
+    /**
+     * Show full date and time even for today
+     * @default false
+     */
+    alwaysShowDate?: boolean;
+    /**
+     * Include seconds in time display
+     * @default false
+     */
+    includeSeconds?: boolean;
+    /**
+     * Use 12-hour format instead of 24-hour
+     * @default false
+     */
+    use12Hour?: boolean;
+    /**
+     * Locale for date formatting
+     * @default undefined (uses browser default)
+     */
+    locale?: string;
+}
+/**
+ * Formats a timestamp for display in chat messages, notifications, etc.
+ * Shows time only for today, date + time for other days.
+ */
+export declare const formatTimestamp: (input: DateInput, options?: TimestampOptions) => string;
+/**
+ * Formats a date for display (date only, no time)
+ */
+export declare const formatDate: (input: DateInput, options?: Intl.DateTimeFormatOptions, locale?: string) => string;
+/**
+ * Formats time only (no date)
+ */
+export declare const formatTime: (input: DateInput, options?: {
+    includeSeconds?: boolean;
+    use12Hour?: boolean;
+}, locale?: string) => string;
+/**
+ * Returns a relative time string (e.g., "2 minutes ago", "in 3 hours")
+ */
+export declare const formatRelativeTime: (input: DateInput, locale?: string) => string;
+/**
+ * Checks if a date is today
+ */
+export declare const isToday: (input: DateInput) => boolean;
+/**
+ * Checks if a date is yesterday
+ */
+export declare const isYesterday: (input: DateInput) => boolean;
+/**
+ * Checks if a date is within the current week
+ */
+export declare const isThisWeek: (input: DateInput) => boolean;
+/**
+ * Formats a date using a custom format string
+ * Supports common format tokens for flexible date display
+ *
+ * @param date - The date to format
+ * @param formatString - Format string with tokens (e.g., 'DD MMM YYYY', 'DD/MM/YYYY')
+ * @param locale - Optional locale for month names (default: 'en-US')
+ *
+ * Supported tokens:
+ * - DD: Day with leading zero (01, 02, ..., 31)
+ * - D: Day without leading zero (1, 2, ..., 31)
+ * - MMM: Short month name (Jan, Feb, ..., Dec)
+ * - MMMM: Full month name (January, February, ..., December)
+ * - MM: Month with leading zero (01, 02, ..., 12)
+ * - M: Month without leading zero (1, 2, ..., 12)
+ * - YYYY: Full year (2023, 2024, etc.)
+ * - YY: Two-digit year (23, 24, etc.)
+ *
+ * @example
+ * formatDateCustom(new Date('2023-09-21'), 'DD MMM YYYY') // "21 Sept 2023"
+ * formatDateCustom(new Date('2023-09-21'), 'DD/MM/YYYY') // "21/09/2023"
+ * formatDateCustom(new Date('2023-09-21'), 'MM-DD-YYYY') // "09-21-2023"
+ * formatDateCustom(new Date('2023-09-21'), 'D MMMM YYYY') // "21 September 2023"
+ */
+export declare const formatDateCustom: (date: Date, formatString: string, locale?: string) => string;
+/**
+ * Date range type for utility functions
+ */
+export interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+/**
+ * Get date range for the last N days
+ */
+export declare const getLastNDays: (days: number) => DateRange;
+/**
+ * Get date range for this week (Monday to Sunday)
+ */
+export declare const getThisWeek: () => DateRange;
+/**
+ * Get date range for last week (Monday to Sunday)
+ */
+export declare const getLastWeek: () => DateRange;
+/**
+ * Get date range for this month
+ */
+export declare const getThisMonth: () => DateRange;
+/**
+ * Get date range for last month
+ */
+export declare const getLastMonth: () => DateRange;
+/**
+ * Get date range for this year
+ */
+export declare const getThisYear: () => DateRange;
+/**
+ * Get date range for last year
+ */
+export declare const getLastYear: () => DateRange;

package/dist/utils/dateUtils.js

@@ -0,0 +1,87 @@
+/**
+ * Date and time utility functions for consistent formatting across the component library
+ */
+/**
+ * Formats a timestamp for display in chat messages, notifications, etc.
+ * Shows time only for today, date + time for other days.
+ */
+const formatTimestamp = (input, options = {}) => {
+    const { alwaysShowDate = false, includeSeconds = false, use12Hour = false, locale } = options;
+    const date = new Date(input);
+    // Check if date is valid
+    if (isNaN(date.getTime())) {
+        return 'Invalid date';
+    }
+    // Check if date is today
+    const now = new Date();
+    const isToday = date.toDateString() === now.toDateString();
+    const timeOptions = {
+        hour: '2-digit',
+        minute: '2-digit',
+        ...(includeSeconds && { second: '2-digit' }),
+        ...(use12Hour && { hour12: true }),
+    };
+    if (isToday && !alwaysShowDate) {
+        // Show time only if today
+        return date.toLocaleTimeString(locale ? [locale] : [], timeOptions);
+    }
+    else {
+        // Show date and time if not today or if alwaysShowDate is true
+        return date.toLocaleDateString(locale ? [locale] : [], {
+            month: 'short',
+            day: 'numeric',
+            ...timeOptions,
+        });
+    }
+};
+/**
+ * Formats a date using a custom format string
+ * Supports common format tokens for flexible date display
+ *
+ * @param date - The date to format
+ * @param formatString - Format string with tokens (e.g., 'DD MMM YYYY', 'DD/MM/YYYY')
+ * @param locale - Optional locale for month names (default: 'en-US')
+ *
+ * Supported tokens:
+ * - DD: Day with leading zero (01, 02, ..., 31)
+ * - D: Day without leading zero (1, 2, ..., 31)
+ * - MMM: Short month name (Jan, Feb, ..., Dec)
+ * - MMMM: Full month name (January, February, ..., December)
+ * - MM: Month with leading zero (01, 02, ..., 12)
+ * - M: Month without leading zero (1, 2, ..., 12)
+ * - YYYY: Full year (2023, 2024, etc.)
+ * - YY: Two-digit year (23, 24, etc.)
+ *
+ * @example
+ * formatDateCustom(new Date('2023-09-21'), 'DD MMM YYYY') // "21 Sept 2023"
+ * formatDateCustom(new Date('2023-09-21'), 'DD/MM/YYYY') // "21/09/2023"
+ * formatDateCustom(new Date('2023-09-21'), 'MM-DD-YYYY') // "09-21-2023"
+ * formatDateCustom(new Date('2023-09-21'), 'D MMMM YYYY') // "21 September 2023"
+ */
+const formatDateCustom = (date, formatString, locale = 'en-US') => {
+    if (!(date instanceof Date) || isNaN(date.getTime())) {
+        return 'Invalid date';
+    }
+    const day = date.getDate();
+    const month = date.getMonth() + 1;
+    const year = date.getFullYear();
+    // Get month names based on locale
+    const shortMonths = Array.from({ length: 12 }, (_, i) => new Date(2000, i, 1).toLocaleDateString(locale, { month: 'short' }));
+    const fullMonths = Array.from({ length: 12 }, (_, i) => new Date(2000, i, 1).toLocaleDateString(locale, { month: 'long' }));
+    // Replace tokens in order of length (longest first to avoid conflicts)
+    let result = formatString;
+    // Year tokens
+    result = result.replace(/YYYY/g, year.toString());
+    result = result.replace(/YY/g, year.toString().slice(-2));
+    // Month tokens (MMMM before MMM before MM before M)
+    result = result.replace(/MMMM/g, fullMonths[month - 1]);
+    result = result.replace(/MMM/g, shortMonths[month - 1]);
+    result = result.replace(/MM/g, month.toString().padStart(2, '0'));
+    result = result.replace(/M/g, month.toString());
+    // Day tokens (DD before D)
+    result = result.replace(/DD/g, day.toString().padStart(2, '0'));
+    result = result.replace(/D/g, day.toString());
+    return result;
+};
+
+export { formatDateCustom, formatTimestamp };

package/dist/utils/debounce.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until after
+ * wait milliseconds have elapsed since the last time the debounced function was invoked.
+ *
+ * @param func - The function to debounce
+ * @param wait - The number of milliseconds to delay
+ * @returns A debounced version of the function
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;

package/dist/utils/debounce.js

@@ -0,0 +1,17 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until after
+ * wait milliseconds have elapsed since the last time the debounced function was invoked.
+ *
+ * @param func - The function to debounce
+ * @param wait - The number of milliseconds to delay
+ * @returns A debounced version of the function
+ */
+function debounce(func, wait) {
+    let timeoutId;
+    return (...args) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => func(...args), wait);
+    };
+}
+
+export { debounce };

package/dist/utils/formValidation.d.ts

@@ -0,0 +1,20 @@
+import { StateIdentifier, StateMachineConfig } from "./stateMachine";
+/**
+ * Result of a step validation
+ * Can be a boolean, a string (single error), or an array of strings (multiple errors)
+ */
+export type ValidationResult = boolean | string | string[];
+/**
+ * Enhanced configuration that includes validation predicates for each step
+ */
+export interface ValidatedStateMachineConfig<TData> extends StateMachineConfig<TData> {
+    /** Map of states to validation functions */
+    validation?: Record<StateIdentifier, (data: TData) => ValidationResult | Promise<ValidationResult>>;
+}
+/**
+ * Helper to validate the data for a specific state
+ */
+export declare function validateStep<TData>(config: ValidatedStateMachineConfig<TData>, state: StateIdentifier, data: TData): Promise<{
+    success: boolean;
+    errors?: string[];
+}>;

package/dist/utils/index.d.ts

@@ -0,0 +1,15 @@
+export { cn } from "./cn";
+export { debounce } from "./debounce";
+export { formatTimestamp, formatDate, formatTime, formatDateCustom, formatRelativeTime, isToday, isYesterday, isThisWeek, getLastNDays, getThisWeek, getLastWeek, getThisMonth, getLastMonth, getThisYear, getLastYear, type DateInput, type TimestampOptions, type DateRange, } from "./dateUtils";
+export { useClickOutside } from "./useClickOutside";
+export { findNextMatchingOption, isValidTypeaheadChar, TYPEAHEAD_TIMEOUT_MS, type TypeaheadOption, type FindNextMatchingOptionParams, } from "./typeaheadUtils";
+export { timeToMinutes, minutesToTime, getEventDuration, getTotalTimeSlots, getTimeSlotIndex, getTimeSlotForIndex, calculateEventPosition, calculateEventHeight, eventsOverlap, findOverlappingEvents, groupOverlappingEvents, resolveOverlappingEvents, generateTimeGrid, filterEventsByDate, sortEventsByStartTime, separateAllDayEvents, isValidTimeFormat, isValidDateFormat, validateEvent, DEFAULT_GRID_CONFIGS, type CalendarEvent, type GridConfig, type EventPosition, type EventLayout, type TimeSlot, } from "./calendarUtils";
+export { parseOpenAI, parseAnthropic, parseGemini, parseSSELine, SSE_PARSERS, type SSEFormat, type SSEParser, } from "./sseFormatParsers";
+export { StreamingNetworkError, StreamingTimeoutError, StreamingParseError, StreamingAbortError, StreamingServerError, normalizeError, type StreamingError, } from "./streamingErrors";
+export { calculateRetryDelay, shouldRetry, type RetryConfig, } from "./retryUtils";
+export { MutationError, RollbackError, QueueError, OptimisticNetworkError, normalizeOptimisticError, isOptimisticError, type OptimisticError, } from "./optimisticErrors";
+export { ActionQueue, createActionQueue, getDefaultQueue, type QueuedAction, type ActionQueueOptions, type AddActionOptions, } from "./actionQueue";
+export * from "./stateMachine";
+export * from "./formValidation";
+export { calculateVelocity, clampScroll, detectScrollDirection, isReducedMotion, lerp, calculateScrollProgress, normalizeWheelDelta, isScrollable, getMaxScroll, throttle, } from './smoothScrollUtils';
+export { PerformanceMonitor, usePerformanceMonitor } from './performanceMonitor';

package/dist/utils/optimisticErrors.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Optimistic Mutation Error Classes
+ * Defines error types for optimistic UI updates with rollback support
+ */
+/**
+ * Base optimistic error interface
+ */
+export interface OptimisticError {
+    type: "mutation" | "rollback" | "queue" | "network";
+    message: string;
+    originalData?: unknown;
+    rollbackData?: unknown;
+    retryable: boolean;
+}
+/**
+ * Mutation error - occurs when the server rejects the mutation
+ * Retryable: Depends on error type (network yes, validation no)
+ */
+export declare class MutationError extends Error implements OptimisticError {
+    retryable: boolean;
+    originalData?: unknown | undefined;
+    rollbackData?: unknown | undefined;
+    details?: unknown | undefined;
+    type: "mutation";
+    constructor(message: string, retryable?: boolean, originalData?: unknown | undefined, rollbackData?: unknown | undefined, details?: unknown | undefined);
+}
+/**
+ * Rollback error - occurs when attempting to rollback optimistic state fails
+ * Retryable: No (indicates a serious state corruption issue)
+ */
+export declare class RollbackError extends Error implements OptimisticError {
+    originalData?: unknown | undefined;
+    rollbackData?: unknown | undefined;
+    details?: unknown | undefined;
+    type: "rollback";
+    retryable: boolean;
+    constructor(message: string, originalData?: unknown | undefined, rollbackData?: unknown | undefined, details?: unknown | undefined);
+}
+/**
+ * Queue error - occurs when action queue operations fail
+ * Retryable: Yes (queue operations can be retried)
+ */
+export declare class QueueError extends Error implements OptimisticError {
+    actionId?: string | undefined;
+    details?: unknown | undefined;
+    type: "queue";
+    retryable: boolean;
+    constructor(message: string, actionId?: string | undefined, details?: unknown | undefined);
+    originalData: undefined;
+    rollbackData: undefined;
+}
+/**
+ * Network error for optimistic operations - typically connection issues
+ * Retryable: Yes
+ */
+export declare class OptimisticNetworkError extends Error implements OptimisticError {
+    originalData?: unknown | undefined;
+    rollbackData?: unknown | undefined;
+    details?: unknown | undefined;
+    type: "network";
+    retryable: boolean;
+    constructor(message: string, originalData?: unknown | undefined, rollbackData?: unknown | undefined, details?: unknown | undefined);
+}
+/**
+ * Normalize any error into an OptimisticError
+ * Used to convert unknown errors into typed optimistic errors
+ *
+ * @param error - Any error object
+ * @param context - Optional context for rollback (originalData, rollbackData)
+ * @returns Normalized OptimisticError
+ */
+export declare const normalizeOptimisticError: (error: unknown, context?: {
+    originalData?: unknown;
+    rollbackData?: unknown;
+}) => OptimisticError;
+/**
+ * Check if an error is an OptimisticError
+ */
+export declare const isOptimisticError: (error: unknown) => error is OptimisticError;

package/dist/utils/optimisticErrors.js

@@ -0,0 +1,27 @@
+/**
+ * Optimistic Mutation Error Classes
+ * Defines error types for optimistic UI updates with rollback support
+ */
+/**
+ * Mutation error - occurs when the server rejects the mutation
+ * Retryable: Depends on error type (network yes, validation no)
+ */
+/**
+ * Queue error - occurs when action queue operations fail
+ * Retryable: Yes (queue operations can be retried)
+ */
+class QueueError extends Error {
+    constructor(message, actionId, details) {
+        super(message);
+        this.actionId = actionId;
+        this.details = details;
+        this.type = "queue";
+        this.retryable = true;
+        this.name = "QueueError";
+        // Queue errors don't have original/rollback data
+        this.originalData = undefined;
+        this.rollbackData = undefined;
+    }
+}
+
+export { QueueError };