@revealui/core 0.2.1 → 0.5.0

package/dist/error-handling/retry.d.ts

@@ -1,194 +0,0 @@
-/**
- * Retry Logic for API Calls
- *
- * Implements exponential backoff and retry strategies
- */
-export interface HttpError extends Error {
-    statusCode?: number;
-    response?: Response;
-}
-export interface RetryConfig {
-    maxRetries?: number;
-    baseDelay?: number;
-    maxDelay?: number;
-    exponentialBackoff?: boolean;
-    jitter?: boolean;
-    retryableErrors?: (error: Error) => boolean;
-    onRetry?: (error: Error, attempt: number) => void;
-}
-export interface RetryOptions {
-    signal?: AbortSignal;
-}
-/**
- * Retry a function with exponential backoff
- */
-export declare function retry<T>(fn: () => Promise<T>, config?: RetryConfig, options?: RetryOptions): Promise<T>;
-/**
- * Calculate retry delay with exponential backoff
- */
-export declare function calculateDelay(attempt: number, baseDelay: number, maxDelay: number, exponentialBackoff: boolean, jitter: boolean): number;
-/**
- * Sleep with abort support
- */
-export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
-/**
- * Retry wrapper for fetch
- */
-export declare function fetchWithRetry(url: string, init?: RequestInit, config?: RetryConfig): Promise<Response>;
-/**
- * Retry wrapper class
- */
-export declare class RetryableOperation<T> {
-    private fn;
-    private config;
-    private abortController;
-    private attempts;
-    private lastError?;
-    constructor(fn: () => Promise<T>, config?: RetryConfig);
-    /**
-     * Execute with retry
-     */
-    execute(): Promise<T>;
-    /**
-     * Abort operation
-     */
-    abort(): void;
-    /**
-     * Get retry statistics
-     */
-    getStats(): {
-        attempts: number;
-        lastError?: Error;
-    };
-}
-/**
- * Retry decorator
- */
-export declare function Retryable(config?: RetryConfig): (_target: object, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * Create retry middleware for API client
- */
-export declare function createRetryMiddleware<TRequest = unknown, TResponse = unknown>(config?: RetryConfig): (_request: TRequest, next: () => Promise<TResponse>) => Promise<TResponse>;
-/**
- * Batch retry - retry multiple operations
- */
-export declare function retryBatch<T>(operations: Array<() => Promise<T>>, config?: RetryConfig): Promise<Array<T | Error>>;
-/**
- * Retry with fallback
- */
-export declare function retryWithFallback<T>(primary: () => Promise<T>, fallback: () => Promise<T>, config?: RetryConfig): Promise<T>;
-/**
- * Conditional retry - only retry if condition is met
- */
-export declare function retryIf<T>(fn: () => Promise<T>, condition: (error: Error, attempt: number) => boolean, config?: RetryConfig): Promise<T>;
-/**
- * Retry until condition is met
- */
-export declare function retryUntil<T>(fn: () => Promise<T>, predicate: (result: T) => boolean, config?: RetryConfig, maxAttempts?: number): Promise<T>;
-/**
- * Exponential backoff iterator
- */
-export declare class ExponentialBackoff implements AsyncIterable<number> {
-    private baseDelay;
-    private maxDelay;
-    private maxAttempts;
-    private jitter;
-    constructor(baseDelay?: number, maxDelay?: number, maxAttempts?: number, jitter?: boolean);
-    [Symbol.asyncIterator](): AsyncIterator<number>;
-}
-/**
- * Retry policy builder
- */
-export declare class RetryPolicyBuilder {
-    private config;
-    /**
-     * Set max retries
-     */
-    maxRetries(count: number): this;
-    /**
-     * Set base delay
-     */
-    baseDelay(ms: number): this;
-    /**
-     * Set max delay
-     */
-    maxDelay(ms: number): this;
-    /**
-     * Enable/disable exponential backoff
-     */
-    exponentialBackoff(enabled?: boolean): this;
-    /**
-     * Enable/disable jitter
-     */
-    jitter(enabled?: boolean): this;
-    /**
-     * Set custom retryable errors function
-     */
-    retryOn(fn: (error: Error) => boolean): this;
-    /**
-     * Set retry callback
-     */
-    onRetry(fn: (error: Error, attempt: number) => void): this;
-    /**
-     * Build retry config
-     */
-    build(): RetryConfig;
-    /**
-     * Execute function with built policy
-     */
-    execute<T>(fn: () => Promise<T>): Promise<T>;
-}
-/**
- * Common retry policies
- */
-export declare const RetryPolicies: {
-    /**
-     * Default policy - 3 retries with exponential backoff
-     */
-    default: () => RetryConfig;
-    /**
-     * Aggressive policy - more retries, faster backoff
-     */
-    aggressive: () => RetryConfig;
-    /**
-     * Conservative policy - fewer retries, longer backoff
-     */
-    conservative: () => RetryConfig;
-    /**
-     * Linear backoff policy
-     */
-    linear: () => RetryConfig;
-    /**
-     * Immediate retry policy - no delay
-     */
-    immediate: () => RetryConfig;
-    /**
-     * Network error only policy
-     */
-    networkOnly: () => RetryConfig;
-    /**
-     * Idempotent operations policy (safe to retry)
-     */
-    idempotent: () => RetryConfig;
-};
-/**
- * Global retry configuration
- */
-declare class GlobalRetryConfig {
-    private config;
-    /**
-     * Set global retry config
-     */
-    setConfig(config: RetryConfig): void;
-    /**
-     * Get global retry config
-     */
-    getConfig(): RetryConfig;
-    /**
-     * Reset to default config
-     */
-    reset(): void;
-}
-export declare const globalRetryConfig: GlobalRetryConfig;
-export {};
-//# sourceMappingURL=retry.d.ts.map

package/dist/error-handling/retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/error-handling/retry.ts"],"names":[],"mappings":"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"}

package/dist/error-handling/retry.js

@@ -1,450 +0,0 @@
-/**
- * Retry Logic for API Calls
- *
- * Implements exponential backoff and retry strategies
- */
-import { logger } from '../observability/logger.js';
-const DEFAULT_CONFIG = {
-    maxRetries: 3,
-    baseDelay: 1000,
-    maxDelay: 30000,
-    exponentialBackoff: true,
-    jitter: true,
-    retryableErrors: (error) => {
-        // Check for explicit non-retryable status codes (4xx client errors)
-        if ('statusCode' in error) {
-            const statusCode = error.statusCode;
-            // Don't retry 4xx errors except 408 (timeout) and 429 (rate limit)
-            if (statusCode !== undefined && statusCode >= 400 && statusCode < 500) {
-                return statusCode === 408 || statusCode === 429;
-            }
-        }
-        // Retry all other errors by default (network errors, 5xx, generic errors)
-        return true;
-    },
-    onRetry: () => { },
-};
-/**
- * Retry a function with exponential backoff
- */
-export async function retry(fn, config = {}, options = {}) {
-    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-    let lastError;
-    for (let attempt = 0; attempt <= mergedConfig.maxRetries; attempt++) {
-        try {
-            // Check if aborted
-            if (options.signal?.aborted) {
-                throw new Error('Request aborted');
-            }
-            return await fn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            // Don't retry if it's the last attempt
-            if (attempt === mergedConfig.maxRetries) {
-                throw lastError;
-            }
-            // Don't retry if error is not retryable
-            if (!mergedConfig.retryableErrors(lastError)) {
-                throw lastError;
-            }
-            // Call retry callback
-            mergedConfig.onRetry(lastError, attempt + 1);
-            // Calculate delay
-            const delay = calculateDelay(attempt, mergedConfig.baseDelay, mergedConfig.maxDelay, mergedConfig.exponentialBackoff, mergedConfig.jitter);
-            // Wait before retrying
-            await sleep(delay, options.signal);
-        }
-    }
-    throw lastError;
-}
-/**
- * Calculate retry delay with exponential backoff
- */
-export function calculateDelay(attempt, baseDelay, maxDelay, exponentialBackoff, jitter) {
-    let delay = baseDelay;
-    if (exponentialBackoff) {
-        // Exponential backoff: 2^attempt * baseDelay
-        delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
-    }
-    if (jitter) {
-        // Add random jitter (±25%)
-        const jitterAmount = delay * 0.25;
-        delay = delay + (Math.random() * jitterAmount * 2 - jitterAmount);
-    }
-    return Math.floor(delay);
-}
-/**
- * Sleep with abort support
- */
-export function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(new Error('Request aborted'));
-            return;
-        }
-        const timeout = setTimeout(resolve, ms);
-        if (signal) {
-            signal.addEventListener('abort', () => {
-                clearTimeout(timeout);
-                reject(new Error('Request aborted'));
-            });
-        }
-    });
-}
-/**
- * Retry wrapper for fetch
- */
-export async function fetchWithRetry(url, init, config) {
-    const abortController = new AbortController();
-    const signal = init?.signal || abortController.signal;
-    return retry(async () => {
-        const response = await fetch(url, {
-            ...init,
-            signal,
-        });
-        // Throw on error status
-        if (!response.ok) {
-            const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
-            error.statusCode = response.status;
-            error.response = response;
-            throw error;
-        }
-        return response;
-    }, {
-        ...config,
-        retryableErrors: (error) => {
-            // Check custom retryable errors first
-            if (config?.retryableErrors && !config.retryableErrors(error)) {
-                return false;
-            }
-            // Don't retry 4xx errors (except 408, 429)
-            if ('statusCode' in error) {
-                const statusCode = error.statusCode;
-                if (statusCode !== undefined && statusCode >= 400 && statusCode < 500) {
-                    return statusCode === 408 || statusCode === 429;
-                }
-            }
-            return true;
-        },
-    }, { signal });
-}
-/**
- * Retry wrapper class
- */
-export class RetryableOperation {
-    fn;
-    config;
-    abortController;
-    attempts = 0;
-    lastError;
-    constructor(fn, config = {}) {
-        this.fn = fn;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.abortController = new AbortController();
-    }
-    /**
-     * Execute with retry
-     */
-    async execute() {
-        return retry(this.fn, this.config, { signal: this.abortController.signal });
-    }
-    /**
-     * Abort operation
-     */
-    abort() {
-        this.abortController.abort();
-    }
-    /**
-     * Get retry statistics
-     */
-    getStats() {
-        return {
-            attempts: this.attempts,
-            lastError: this.lastError,
-        };
-    }
-}
-/**
- * Retry decorator
- */
-export function Retryable(config) {
-    return (_target, _propertyKey, descriptor) => {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            return retry(() => originalMethod.apply(this, args), config);
-        };
-        return descriptor;
-    };
-}
-/**
- * Create retry middleware for API client
- */
-export function createRetryMiddleware(config = {}) {
-    return async (_request, next) => {
-        return retry(next, config);
-    };
-}
-/**
- * Batch retry - retry multiple operations
- */
-export async function retryBatch(operations, config = {}) {
-    return Promise.all(operations.map(async (op) => {
-        try {
-            return await retry(op, config);
-        }
-        catch (error) {
-            return error instanceof Error ? error : new Error(String(error));
-        }
-    }));
-}
-/**
- * Retry with fallback
- */
-export async function retryWithFallback(primary, fallback, config = {}) {
-    try {
-        return await retry(primary, config);
-    }
-    catch (error) {
-        logger.warn('Primary operation failed, trying fallback', {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return fallback();
-    }
-}
-/**
- * Conditional retry - only retry if condition is met
- */
-export async function retryIf(fn, condition, config = {}) {
-    return retry(fn, {
-        ...config,
-        retryableErrors: (error) => {
-            // Check original retryable condition first
-            const originalCheck = config.retryableErrors?.(error) ?? DEFAULT_CONFIG.retryableErrors(error);
-            if (!originalCheck)
-                return false;
-            // Then check custom condition
-            return condition(error, 0);
-        },
-    });
-}
-/**
- * Retry until condition is met
- */
-export async function retryUntil(fn, predicate, config = {}, maxAttempts = 10) {
-    let attempts = 0;
-    while (attempts < maxAttempts) {
-        try {
-            const result = await fn();
-            if (predicate(result)) {
-                return result;
-            }
-            // Result doesn't match predicate, treat as retryable error
-            attempts++;
-            if (attempts >= maxAttempts) {
-                throw new Error('Max attempts reached without matching predicate');
-            }
-            const delay = calculateDelay(attempts - 1, config.baseDelay || DEFAULT_CONFIG.baseDelay, config.maxDelay || DEFAULT_CONFIG.maxDelay, config.exponentialBackoff ?? DEFAULT_CONFIG.exponentialBackoff, config.jitter ?? DEFAULT_CONFIG.jitter);
-            await sleep(delay);
-        }
-        catch (error) {
-            attempts++;
-            if (attempts >= maxAttempts) {
-                throw error;
-            }
-            const delay = calculateDelay(attempts - 1, config.baseDelay || DEFAULT_CONFIG.baseDelay, config.maxDelay || DEFAULT_CONFIG.maxDelay, config.exponentialBackoff ?? DEFAULT_CONFIG.exponentialBackoff, config.jitter ?? DEFAULT_CONFIG.jitter);
-            await sleep(delay);
-        }
-    }
-    throw new Error('Max attempts reached');
-}
-/**
- * Exponential backoff iterator
- */
-export class ExponentialBackoff {
-    baseDelay;
-    maxDelay;
-    maxAttempts;
-    jitter;
-    constructor(baseDelay = 1000, maxDelay = 30000, maxAttempts = 10, jitter = true) {
-        this.baseDelay = baseDelay;
-        this.maxDelay = maxDelay;
-        this.maxAttempts = maxAttempts;
-        this.jitter = jitter;
-    }
-    async *[Symbol.asyncIterator]() {
-        for (let attempt = 0; attempt < this.maxAttempts; attempt++) {
-            const delay = calculateDelay(attempt, this.baseDelay, this.maxDelay, true, this.jitter);
-            yield delay;
-            await sleep(delay);
-        }
-    }
-}
-/**
- * Retry policy builder
- */
-export class RetryPolicyBuilder {
-    config = {};
-    /**
-     * Set max retries
-     */
-    maxRetries(count) {
-        this.config.maxRetries = count;
-        return this;
-    }
-    /**
-     * Set base delay
-     */
-    baseDelay(ms) {
-        this.config.baseDelay = ms;
-        return this;
-    }
-    /**
-     * Set max delay
-     */
-    maxDelay(ms) {
-        this.config.maxDelay = ms;
-        return this;
-    }
-    /**
-     * Enable/disable exponential backoff
-     */
-    exponentialBackoff(enabled = true) {
-        this.config.exponentialBackoff = enabled;
-        return this;
-    }
-    /**
-     * Enable/disable jitter
-     */
-    jitter(enabled = true) {
-        this.config.jitter = enabled;
-        return this;
-    }
-    /**
-     * Set custom retryable errors function
-     */
-    retryOn(fn) {
-        this.config.retryableErrors = fn;
-        return this;
-    }
-    /**
-     * Set retry callback
-     */
-    onRetry(fn) {
-        this.config.onRetry = fn;
-        return this;
-    }
-    /**
-     * Build retry config
-     */
-    build() {
-        return this.config;
-    }
-    /**
-     * Execute function with built policy
-     */
-    async execute(fn) {
-        return retry(fn, this.build());
-    }
-}
-/**
- * Common retry policies
- */
-export const RetryPolicies = {
-    /**
-     * Default policy - 3 retries with exponential backoff
-     */
-    default: () => ({
-        maxRetries: 3,
-        baseDelay: 1000,
-        maxDelay: 30000,
-        exponentialBackoff: true,
-        jitter: true,
-    }),
-    /**
-     * Aggressive policy - more retries, faster backoff
-     */
-    aggressive: () => ({
-        maxRetries: 5,
-        baseDelay: 500,
-        maxDelay: 10000,
-        exponentialBackoff: true,
-        jitter: true,
-    }),
-    /**
-     * Conservative policy - fewer retries, longer backoff
-     */
-    conservative: () => ({
-        maxRetries: 2,
-        baseDelay: 2000,
-        maxDelay: 60000,
-        exponentialBackoff: true,
-        jitter: true,
-    }),
-    /**
-     * Linear backoff policy
-     */
-    linear: () => ({
-        maxRetries: 3,
-        baseDelay: 1000,
-        maxDelay: 10000,
-        exponentialBackoff: false,
-        jitter: false,
-    }),
-    /**
-     * Immediate retry policy - no delay
-     */
-    immediate: () => ({
-        maxRetries: 3,
-        baseDelay: 0,
-        maxDelay: 0,
-        exponentialBackoff: false,
-        jitter: false,
-    }),
-    /**
-     * Network error only policy
-     */
-    networkOnly: () => ({
-        maxRetries: 3,
-        baseDelay: 1000,
-        maxDelay: 30000,
-        exponentialBackoff: true,
-        jitter: true,
-        retryableErrors: (error) => error.name === 'NetworkError',
-    }),
-    /**
-     * Idempotent operations policy (safe to retry)
-     */
-    idempotent: () => ({
-        maxRetries: 5,
-        baseDelay: 1000,
-        maxDelay: 30000,
-        exponentialBackoff: true,
-        jitter: true,
-    }),
-};
-/**
- * Global retry configuration
- */
-class GlobalRetryConfig {
-    config = RetryPolicies.default();
-    /**
-     * Set global retry config
-     */
-    setConfig(config) {
-        this.config = { ...this.config, ...config };
-    }
-    /**
-     * Get global retry config
-     */
-    getConfig() {
-        return this.config;
-    }
-    /**
-     * Reset to default config
-     */
-    reset() {
-        this.config = RetryPolicies.default();
-    }
-}
-export const globalRetryConfig = new GlobalRetryConfig();

package/dist/errors/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * RevealUI CMS Errors
- * @module @revealui/core/errors
- */
-export declare class RevealUIError extends Error {
-    constructor(message: string);
-}
-export declare class MissingEditorProp extends RevealUIError {
-    constructor(fieldName?: string);
-}
-export declare class ValidationError extends RevealUIError {
-    constructor(message: string);
-}
-export declare class ConfigurationError extends RevealUIError {
-    constructor(message: string);
-}
-export declare class AccessDeniedError extends RevealUIError {
-    constructor(message?: string);
-}
-export declare class NotFoundError extends RevealUIError {
-    constructor(resource?: string);
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,iBAAkB,SAAQ,aAAa;gBACtC,SAAS,CAAC,EAAE,MAAM;CAI/B;AAED,qBAAa,eAAgB,SAAQ,aAAa;gBACpC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,kBAAmB,SAAQ,aAAa;gBACvC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,iBAAkB,SAAQ,aAAa;gBACtC,OAAO,SAAkB;CAItC;AAED,qBAAa,aAAc,SAAQ,aAAa;gBAClC,QAAQ,CAAC,EAAE,MAAM;CAI9B"}