@plyaz/api 1.0.2 → 1.1.0

package/dist/api/request/utils.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Abort requests by pattern
+ *
+ * @param pattern - URL pattern to match
+ * @param reason - Optional abort reason
+ *
+ * @example
+ * ```typescript
+ * // Abort all search requests
+ * abortByPattern('/api/search/*', 'New search started');
+ * ```
+ */
+export declare function abortByPattern(pattern: string, reason?: string): void;
+/**
+ * Abort all search requests
+ *
+ * @param reason - Optional abort reason
+ */
+export declare function abortSearchRequests(reason?: string): void;
+/**
+ * Abort all upload requests
+ *
+ * @param reason - Optional abort reason
+ */
+export declare function abortUploadRequests(reason?: string): void;
+/**
+ * Abort all pending API requests
+ *
+ * @param reason - Optional abort reason
+ */
+export declare function abortAllRequests(reason?: string): void;
+/**
+ * Create scoped abort function for a specific API namespace
+ *
+ * @param scope - Scope prefix for requests
+ * @returns Scoped abort function
+ *
+ * @example
+ * ```typescript
+ * const abortUserRequests = createScopedAbort('/api/users');
+ *
+ * // Later: abort all user requests
+ * abortUserRequests('profile', 'User logged out');
+ * // This aborts: /api/users/profile
+ * ```
+ */
+export declare function createScopedAbort(scope: string): (key: string, reason?: string) => void;
+/**
+ * Debounced abort - useful for search-as-you-type
+ *
+ * @param delay - Delay in milliseconds
+ * @returns Debounced abort function
+ *
+ * @example
+ * ```typescript
+ * const debouncedAbort = createDebouncedAbort(300);
+ *
+ * // On each keystroke
+ * debouncedAbort('/api/search', 'New search query');
+ * // Only aborts after 300ms of no calls
+ * ```
+ */
+export declare function createDebouncedAbort(delay?: number): {
+    (key: string, reason?: string): void;
+    cancel: () => void;
+};
+/**
+ * Throttled abort - limits abort frequency
+ *
+ * @param limit - Minimum time between aborts (ms)
+ * @returns Throttled abort function
+ */
+export declare function createThrottledAbort(limit?: number): (key: string, reason?: string) => void;
+/**
+ * Request with timeout - automatically aborts after timeout
+ *
+ * @param key - Request identifier
+ * @param fetcher - Function that performs the request
+ * @param timeoutMs - Timeout in milliseconds
+ * @returns Promise with request result
+ *
+ * @example
+ * ```typescript
+ * const data = await requestWithTimeout(
+ *   '/api/slow-endpoint',
+ *   () => fetch('/api/slow-endpoint').then(r => r.json()),
+ *   5000 // 5 second timeout
+ * );
+ * ```
+ */
+export declare function requestWithTimeout<T>(key: string, fetcher: () => Promise<T>, timeoutMs: number): Promise<T>;
+/**
+ * Race multiple requests and abort losers
+ *
+ * @param requests - Array of request configurations
+ * @returns Promise with winner's result
+ *
+ * @example
+ * ```typescript
+ * const fastest = await raceRequests([
+ *   { key: 'primary', fetcher: () => fetchPrimary() },
+ *   { key: 'backup', fetcher: () => fetchBackup() }
+ * ]);
+ * ```
+ */
+export declare function raceRequests<T>(requests: Array<{
+    key: string;
+    fetcher: () => Promise<T>;
+}>): Promise<T>;
+/**
+ * Sequential request chain with abort on failure
+ *
+ * @param requests - Array of request configurations
+ * @returns Array of results
+ *
+ * @example
+ * ```typescript
+ * const results = await sequentialRequests([
+ *   { key: 'step1', fetcher: () => doStep1() },
+ *   { key: 'step2', fetcher: () => doStep2() },
+ *   { key: 'step3', fetcher: () => doStep3() }
+ * ]);
+ * ```
+ */
+export declare function sequentialRequests<T>(requests: Array<{
+    key: string;
+    fetcher: () => Promise<T>;
+}>): Promise<T[]>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/api/request/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/api/request/utils.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAErE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAKvF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,GAAE,MAAY,GAAG;IACzD,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAIA;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,GAAE,MAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAIjG;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,CAAC,CAAC,CAUZ;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,QAAQ,EAAE,KAAK,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;CAC3B,CAAC,GACD,OAAO,CAAC,CAAC,CAAC,CAgBZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,QAAQ,EAAE,KAAK,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;CAC3B,CAAC,GACD,OAAO,CAAC,CAAC,EAAE,CAAC,CAmBd"}

package/dist/api/retry/conditions.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Retry Condition Helpers
+ * Common retry condition functions for custom retry logic
+ *
+ * @module retry/conditions
+ */
+import type { RetryConfig, RetryResponse } from '@plyaz/types/api';
+/**
+ * Common retry condition helpers
+ *
+ * @example
+ * ```typescript
+ * import { retryConditions } from '@plyaz/api/retry';
+ *
+ * const api = createApiClient({
+ *   retry: {
+ *     attempts: 5,
+ *     shouldRetry: retryConditions.networkOnly
+ *   }
+ * });
+ * ```
+ */
+export declare const retryConditions: {
+    /**
+     * Retry only on network errors (no response)
+     */
+    readonly networkOnly: (response: RetryResponse) => boolean;
+    /**
+     * Retry on timeout errors
+     */
+    readonly timeoutOnly: (response: RetryResponse) => boolean;
+    /**
+     * Retry on specific status codes
+     *
+     * @example
+     * ```typescript
+     * shouldRetry: retryConditions.statusCodes([500, 502, 503])
+     * ```
+     */
+    readonly statusCodes: (codes: number[]) => (response: RetryResponse) => boolean;
+    /**
+     * Retry with exponential backoff based on attempt
+     *
+     * @example
+     * ```typescript
+     * shouldRetry: retryConditions.withBackoff(5)
+     * ```
+     */
+    readonly withBackoff: (maxAttempts: number) => (_response: RetryResponse, attempt: number) => boolean;
+    /**
+     * Retry based on custom header presence
+     *
+     * @example
+     * ```typescript
+     * shouldRetry: retryConditions.withHeader('x-retry-allowed', 'true')
+     * ```
+     */
+    readonly withHeader: (headerName: string, headerValue?: string) => (response: RetryResponse) => boolean;
+    /**
+     * Retry if response contains specific error code
+     *
+     * @example
+     * ```typescript
+     * shouldRetry: retryConditions.errorCode(['NETWORK_ERROR', 'TIMEOUT'])
+     * ```
+     */
+    readonly errorCode: (codes: string[]) => (response: RetryResponse) => boolean;
+    /**
+     * Combine multiple conditions (AND)
+     * All conditions must be true to retry
+     *
+     * @example
+     * ```typescript
+     * shouldRetry: retryConditions.all(
+     *   retryConditions.networkOnly,
+     *   retryConditions.withBackoff(3)
+     * )
+     * ```
+     */
+    readonly all: (...conditions: Array<(response: RetryResponse, attempt: number) => boolean>) => (response: RetryResponse, attempt: number) => boolean;
+    /**
+     * Combine multiple conditions (OR)
+     * Any condition being true will trigger retry
+     *
+     * @example
+     * ```typescript
+     * shouldRetry: retryConditions.any(
+     *   retryConditions.networkOnly,
+     *   retryConditions.timeoutOnly,
+     *   retryConditions.statusCodes([500, 502, 503])
+     * )
+     * ```
+     */
+    readonly any: (...conditions: Array<(response: RetryResponse, attempt: number) => boolean>) => (response: RetryResponse, attempt: number) => boolean;
+    /**
+     * Retry based on rate limit headers
+     * Respects X-RateLimit-Remaining and Retry-After headers
+     */
+    readonly rateLimit: (response: RetryResponse, attempt: number) => boolean;
+    /**
+     * Retry on server errors (5xx status codes)
+     */
+    readonly serverErrors: (response: RetryResponse) => boolean;
+    /**
+     * Retry on client errors that might be transient (408, 429)
+     */
+    readonly transientErrors: (response: RetryResponse) => boolean;
+};
+/**
+ * Create custom retry configuration with condition
+ *
+ * @example
+ * ```typescript
+ * const customRetry = createRetryConfig({
+ *   attempts: 5,
+ *   delay: 2000,
+ *   shouldRetry: retryConditions.serverErrors
+ * });
+ * ```
+ */
+export declare function createRetryConfig(options: Partial<RetryConfig>): RetryConfig;
+/**
+ * Wrap a RetryResponse condition to accept unknown
+ * This allows our conditions to work with fetchff's unknown type
+ */
+export declare function wrapCondition(condition: (response: RetryResponse, attempt: number) => boolean): (response: unknown, attempt: number) => boolean;
+/**
+ * Create a retry condition that limits retries per status code
+ *
+ * @example
+ * ```typescript
+ * shouldRetry: createStatusCodeLimits({
+ *   500: 5,  // Retry 500 errors up to 5 times
+ *   503: 3,  // Retry 503 errors up to 3 times
+ *   429: 10  // Retry rate limits up to 10 times
+ * })
+ * ```
+ */
+export declare function createStatusCodeLimits(limits: Record<number, number>): (response: RetryResponse, attempt: number) => boolean;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/api/retry/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../../src/api/retry/conditions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAyDnE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;qCACqB,aAAa;IAErC;;OAEG;qCACqB,aAAa;IAGrC;;;;;;;OAOG;kCACkB,MAAM,EAAE,gBAAgB,aAAa;IAG1D;;;;;;;OAOG;wCACwB,MAAM,iBAAiB,aAAa,WAAW,MAAM;IAGhF;;;;;;;OAOG;sCACsB,MAAM,gBAAgB,MAAM,gBAAgB,aAAa;IAYlF;;;;;;;OAOG;gCACgB,MAAM,EAAE,gBAAgB,aAAa;IAExD;;;;;;;;;;;OAWG;kCAEe,KAAK,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,gBACjE,aAAa,WAAW,MAAM;IAG3C;;;;;;;;;;;;OAYG;kCAEe,KAAK,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,gBACjE,aAAa,WAAW,MAAM;IAG3C;;;OAGG;mCACmB,aAAa,WAAW,MAAM;IAcpD;;OAEG;sCACsB,aAAa;IAUtC;;OAEG;yCACyB,aAAa;CAQjC,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAW5E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,GAC/D,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAIjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAYvD"}

package/dist/api/retry/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Retry Mechanism Module
+ * Provides retry strategies and utilities for handling failed requests
+ *
+ * @module retry
+ */
+export type { RetryConfig, RetryStrategyName, RetryOption } from '@plyaz/types/api';
+export { retryStrategies, createRetryStrategy, getRetryStrategy, applyRetryStrategy, mergeRetryStrategies, } from './strategies';
+export { retryConditions, createRetryConfig, createStatusCodeLimits, wrapCondition, } from './conditions';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/retry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/retry/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpF,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,aAAa,GACd,MAAM,cAAc,CAAC"}

package/dist/api/retry/strategies.d.ts

@@ -0,0 +1,56 @@
+import type { RetryConfig, RetryStrategyName } from '@plyaz/types/api';
+/**
+ * Pre-configured retry strategies for common use cases
+ *
+ * @example
+ * ```typescript
+ * import { retryStrategies } from '@plyaz/api/retry';
+ *
+ * // Use in API client
+ * const api = createApiClient({
+ *   retry: retryStrategies.aggressive
+ * });
+ *
+ * // Or use by name
+ * const api = createApiClient({
+ *   retry: 'aggressive'
+ * });
+ * ```
+ */
+export declare const retryStrategies: Readonly<Record<RetryStrategyName, RetryConfig>>;
+/**
+ * Helper to create custom retry strategy
+ *
+ * @example
+ * ```typescript
+ * const customRetry = createRetryStrategy({
+ *   attempts: 5,
+ *   delay: 2000,
+ *   backoff: 1.5
+ * });
+ * ```
+ */
+export declare function createRetryStrategy(config: RetryConfig): RetryConfig;
+/**
+ * Get retry strategy by name with runtime validation
+ */
+export declare function getRetryStrategy(name: RetryStrategyName): RetryConfig;
+/**
+ * Apply retry strategy by name or config
+ *
+ * @param strategy - Strategy name or config object
+ * @returns Retry configuration
+ *
+ * @example
+ * ```typescript
+ * const config = applyRetryStrategy('aggressive');
+ * // or
+ * const config = applyRetryStrategy({ attempts: 5 });
+ * ```
+ */
+export declare function applyRetryStrategy(strategy: RetryStrategyName | RetryConfig | false): RetryConfig | undefined;
+/**
+ * Merge multiple retry strategies (last wins)
+ */
+export declare function mergeRetryStrategies(...configs: (RetryConfig | undefined)[]): RetryConfig;
+//# sourceMappingURL=strategies.d.ts.map

package/dist/api/retry/strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategies.d.ts","sourceRoot":"","sources":["../../../src/api/retry/strategies.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAoB,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAuEzF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,CA2HnE,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAQpE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,WAAW,CAsCrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,GAAG,WAAW,GAAG,KAAK,GAChD,WAAW,GAAG,SAAS,CAuBzB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,OAAO,EAAE,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,GAAG,WAAW,CAQzF"}

package/dist/api/revalidation/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Revalidation Configuration Module
+ * Provides revalidation strategies and utilities for fetchff's cache revalidation features
+ *
+ * @module @plyaz/api/revalidation
+ */
+/**
+ * Re-export fetchff's revalidation utilities
+ * These are direct pass-through exports for manual cache revalidation
+ */
+export { revalidate, revalidateAll, removeRevalidators } from 'fetchff';
+/**
+ * Export revalidation strategies and utilities
+ */
+export { revalidationStrategies, genericPresets, getPresets, extendPresets, resetPresets, getPreset, createRevalidationStrategy, getRevalidationStrategy, applyRevalidationStrategy, isValidStrategyName, mergeRevalidationStrategies, } from './strategies';
+/**
+ * Export SSR-safe utilities
+ */
+export { getSSRSafeConfig, isRevalidationSupported, calculateCacheDuration, isDataFresh, isCacheValid, createRevalidationKey, isWithinDedupeWindow, getNetworkOptimizedConfig, toFetchffRevalidationConfig, } from './utils';
+/**
+ * Export domain-specific presets (separate import)
+ * These are not included by default to keep bundle size small
+ * Import them explicitly when needed:
+ *
+ * @example
+ * import { domainPresets } from '@plyaz/api/revalidation/presets';
+ */
+export { domainPresets, ecommercePresets, socialPresets, financialPresets, contentPresets, enterprisePresets, gamingPresets, iotPresets, healthcarePresets, educationPresets, applyDomainPresets, } from './presets';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/revalidation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/revalidation/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAExE;;GAEG;AACH,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,UAAU,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,0BAA0B,EAC1B,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AAEtB;;GAEG;AACH,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACtB,WAAW,EACX,YAAY,EACZ,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,SAAS,CAAC;AAEjB;;;;;;;GAOG;AACH,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,WAAW,CAAC"}

package/dist/api/revalidation/presets.d.ts

@@ -0,0 +1,71 @@
+import type { RevalidationConfig } from '@plyaz/types/api';
+/**
+ * E-commerce specific presets
+ */
+export declare const ecommercePresets: Record<string, RevalidationConfig>;
+/**
+ * Social media specific presets
+ */
+export declare const socialPresets: Record<string, RevalidationConfig>;
+/**
+ * Financial/Trading specific presets
+ */
+export declare const financialPresets: Record<string, RevalidationConfig>;
+/**
+ * Content management specific presets
+ */
+export declare const contentPresets: Record<string, RevalidationConfig>;
+/**
+ * Enterprise/B2B specific presets
+ */
+export declare const enterprisePresets: Record<string, RevalidationConfig>;
+/**
+ * Gaming specific presets
+ */
+export declare const gamingPresets: Record<string, RevalidationConfig>;
+/**
+ * IoT/Field application specific presets
+ */
+export declare const iotPresets: Record<string, RevalidationConfig>;
+/**
+ * Healthcare specific presets
+ */
+export declare const healthcarePresets: Record<string, RevalidationConfig>;
+/**
+ * Education specific presets
+ */
+export declare const educationPresets: Record<string, RevalidationConfig>;
+/**
+ * All domain presets grouped by category
+ */
+export declare const domainPresets: {
+    readonly ecommerce: Record<string, RevalidationConfig>;
+    readonly social: Record<string, RevalidationConfig>;
+    readonly financial: Record<string, RevalidationConfig>;
+    readonly content: Record<string, RevalidationConfig>;
+    readonly enterprise: Record<string, RevalidationConfig>;
+    readonly gaming: Record<string, RevalidationConfig>;
+    readonly iot: Record<string, RevalidationConfig>;
+    readonly healthcare: Record<string, RevalidationConfig>;
+    readonly education: Record<string, RevalidationConfig>;
+};
+/**
+ * Helper function to apply domain presets
+ *
+ * @param domain - Domain name or custom presets
+ * @returns Applied presets
+ *
+ * @example
+ * // Apply a specific domain
+ * applyDomainPresets('ecommerce');
+ *
+ * // Apply multiple domains
+ * applyDomainPresets(['ecommerce', 'social']);
+ *
+ * // Apply custom presets
+ * applyDomainPresets({
+ *   customEndpoint: revalidationStrategies.balanced
+ * });
+ */
+export declare function applyDomainPresets(domain: keyof typeof domainPresets | (keyof typeof domainPresets)[] | Record<string, RevalidationConfig>): Record<string, RevalidationConfig>;
+//# sourceMappingURL=presets.d.ts.map

package/dist/api/revalidation/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/api/revalidation/presets.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAiB/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAa5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAgB/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAU7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAOhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAO5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAOzD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAOhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAO/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAUhB,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EACF,MAAM,OAAO,aAAa,GAC1B,CAAC,MAAM,OAAO,aAAa,CAAC,EAAE,GAC9B,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GACrC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAcpC"}

package/dist/api/revalidation/strategies.d.ts

@@ -0,0 +1,116 @@
+import type { RevalidationConfig, RevalidationStrategyName } from '@plyaz/types/api';
+/**
+ * Pre-configured revalidation strategies with deduplication
+ * These are configuration options, not implementations
+ *
+ * Based on fetchff best practices for different data volatility levels
+ */
+export declare const revalidationStrategies: Readonly<Record<RevalidationStrategyName, RevalidationConfig>>;
+/**
+ * Generic use case presets
+ * These provide semantic naming for common application patterns
+ * Can be extended with custom presets via extendPresets()
+ */
+export declare const genericPresets: {
+    readonly dashboard: RevalidationConfig;
+    readonly chat: RevalidationConfig;
+    readonly notifications: RevalidationConfig;
+    readonly analytics: RevalidationConfig;
+    readonly feed: RevalidationConfig;
+    readonly content: RevalidationConfig;
+    readonly profile: RevalidationConfig;
+    readonly settings: RevalidationConfig;
+    readonly documentation: RevalidationConfig;
+    readonly assets: RevalidationConfig;
+    readonly config: RevalidationConfig;
+    readonly pwa: RevalidationConfig;
+    readonly mobile: RevalidationConfig;
+};
+/**
+ * Get all current presets
+ *
+ * @returns Current preset registry
+ */
+export declare function getPresets(): Readonly<Record<string, RevalidationConfig>>;
+/**
+ * Extend presets with custom configurations
+ *
+ * @param customPresets - Custom preset configurations
+ * @returns Updated preset registry
+ *
+ * @example
+ * extendPresets({
+ *   ecommerce: revalidationStrategies.balanced,
+ *   tradingPlatform: revalidationStrategies.realtime,
+ *   socialMedia: { ...revalidationStrategies.aggressive, dedupeTime: 500 }
+ * });
+ */
+export declare function extendPresets(customPresets: Record<string, RevalidationConfig>): Readonly<Record<string, RevalidationConfig>>;
+/**
+ * Reset presets to generic defaults
+ * Useful for testing or cleanup
+ */
+export declare function resetPresets(): void;
+/**
+ * Get a preset by name
+ *
+ * @param name - Preset name
+ * @returns Preset configuration or undefined
+ */
+export declare function getPreset(name: string): RevalidationConfig | undefined;
+/**
+ * Create custom revalidation strategy
+ *
+ * @param options - Partial revalidation configuration
+ * @returns Complete revalidation configuration with defaults
+ *
+ * @example
+ * const customStrategy = createRevalidationStrategy({
+ *   refetchOnFocus: true,
+ *   staleTime: 120
+ * });
+ */
+export declare function createRevalidationStrategy(options: Partial<RevalidationConfig>): RevalidationConfig;
+/**
+ * Get a specific strategy with type safety
+ *
+ * @param name - Strategy name to retrieve
+ * @returns The strategy configuration
+ *
+ * @example
+ * const strategy = getRevalidationStrategy('realtime');
+ */
+export declare function getRevalidationStrategy(name: RevalidationStrategyName): RevalidationConfig;
+/**
+ * Apply revalidation strategy by name or config
+ *
+ * @param strategy - Strategy name, config object, or false to disable
+ * @returns Revalidation configuration or undefined
+ *
+ * @example
+ * const config = applyRevalidationStrategy('realtime');
+ * const custom = applyRevalidationStrategy({ refetchOnFocus: true });
+ * const disabled = applyRevalidationStrategy(false);
+ */
+export declare function applyRevalidationStrategy(strategy: RevalidationConfig | RevalidationStrategyName | false): RevalidationConfig | undefined;
+/**
+ * Check if a strategy name is valid
+ *
+ * @param name - Strategy name to check
+ * @returns True if valid strategy name
+ */
+export declare function isValidStrategyName(name: string): name is RevalidationStrategyName;
+/**
+ * Merge multiple revalidation strategies (last wins)
+ *
+ * @param configs - Revalidation configurations to merge
+ * @returns Merged configuration
+ *
+ * @example
+ * const merged = mergeRevalidationStrategies(
+ *   revalidationStrategies.balanced,
+ *   { refetchOnFocus: false }
+ * );
+ */
+export declare function mergeRevalidationStrategies(...configs: (RevalidationConfig | undefined)[]): RevalidationConfig;
+//# sourceMappingURL=strategies.d.ts.map

package/dist/api/revalidation/strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategies.d.ts","sourceRoot":"","sources":["../../../src/api/revalidation/strategies.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,kBAAkB,CAAC;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,wBAAwB,EAAE,kBAAkB,CAAC,CA0GrD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;CAyBjB,CAAC;AAQX;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAEzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAChD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAM9C;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,GACnC,kBAAkB,CAKpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,wBAAwB,GAAG,kBAAkB,CAyB1F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,kBAAkB,GAAG,wBAAwB,GAAG,KAAK,GAC9D,kBAAkB,GAAG,SAAS,CAehC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,wBAAwB,CAElF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,OAAO,EAAE,CAAC,kBAAkB,GAAG,SAAS,CAAC,EAAE,GAC7C,kBAAkB,CAEpB"}

package/dist/api/revalidation/utils.d.ts

@@ -0,0 +1,78 @@
+import type { RevalidationConfig } from '@plyaz/types/api';
+/**
+ * Get SSR-safe revalidation configuration
+ * Disables browser-specific features in server environment
+ *
+ * @param config - Original revalidation configuration
+ * @returns SSR-safe configuration
+ *
+ * @example
+ * const safeConfig = getSSRSafeConfig({
+ *   refetchOnFocus: true,
+ *   refetchOnReconnect: true
+ * });
+ * // On server: { refetchOnFocus: false, refetchOnReconnect: false }
+ * // On client: { refetchOnFocus: true, refetchOnReconnect: true }
+ */
+export declare function getSSRSafeConfig(config: RevalidationConfig): RevalidationConfig;
+/**
+ * Check if revalidation features are supported
+ *
+ * @returns True if browser supports focus/online events
+ */
+export declare function isRevalidationSupported(): boolean;
+/**
+ * Calculate effective cache duration based on config
+ *
+ * @param config - Revalidation configuration
+ * @returns Total cache duration in milliseconds
+ */
+export declare function calculateCacheDuration(config: RevalidationConfig): number;
+/**
+ * Determine if data should be considered fresh
+ *
+ * @param lastFetchTime - Timestamp of last fetch
+ * @param staleTime - Stale time in seconds
+ * @returns True if data is still fresh
+ */
+export declare function isDataFresh(lastFetchTime: number, staleTime: number): boolean;
+/**
+ * Determine if cache is still valid
+ *
+ * @param lastFetchTime - Timestamp of last fetch
+ * @param cacheTime - Cache time in seconds
+ * @returns True if cache is still valid
+ */
+export declare function isCacheValid(lastFetchTime: number, cacheTime: number): boolean;
+/**
+ * Create a revalidation key for deduplication
+ *
+ * @param url - Request URL
+ * @param params - Request parameters
+ * @returns Unique key for the request
+ */
+export declare function createRevalidationKey(url: string, params?: Record<string, unknown>): string;
+/**
+ * Check if request is within deduplication window
+ *
+ * @param lastRequestTime - Timestamp of last request
+ * @param dedupeTime - Deduplication window in milliseconds
+ * @returns True if within deduplication window
+ */
+export declare function isWithinDedupeWindow(lastRequestTime: number, dedupeTime: number): boolean;
+/**
+ * Get optimal revalidation config based on network conditions
+ *
+ * @param baseConfig - Base revalidation configuration
+ * @returns Optimized configuration for current network
+ */
+export declare function getNetworkOptimizedConfig(baseConfig: RevalidationConfig): RevalidationConfig;
+/**
+ * Convert our revalidation config to fetchff format
+ * Maps our naming conventions to fetchff's expected properties
+ *
+ * @param config - Our revalidation configuration
+ * @returns fetchff-compatible configuration
+ */
+export declare function toFetchffRevalidationConfig(config: RevalidationConfig): Record<string, unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/api/revalidation/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/api/revalidation/utils.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAS/E;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CA0BjD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAIzE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAI7E;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAO9E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAwB3F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAMzF;AA4BD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,kBAAkB,GAAG,kBAAkB,CAuB5F;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2B/F"}