@plyaz/api 1.0.2 → 1.1.1

package/dist/api/utils/generation/correlation-id.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Correlation ID Generation Utilities
+ * Provides correlation-specific ID generation for distributed tracing and event correlation
+ */
+import { CORRELATION_TYPE, type IdGenerationOptions } from '@plyaz/types/api';
+/**
+ * Generate a correlation ID
+ * Uses timestamp-based format for efficient sorting and tracing
+ *
+ * @param type - Type of correlation (defaults to GENERIC)
+ * @param options - Optional ID generation options
+ * @returns Correlation identifier
+ *
+ * @example
+ * ```typescript
+ * const correlationId = generateCorrelationId();
+ * // 'corr_1a2b3c4d_5e6f7g8h'
+ *
+ * const networkId = generateCorrelationId(CORRELATION_TYPE.NETWORK);
+ * // 'net_1a2b3c4d_5e6f7g8h'
+ *
+ * const apiId = generateCorrelationId(CORRELATION_TYPE.API);
+ * // 'api_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateCorrelationId(type?: CORRELATION_TYPE | string, options?: IdGenerationOptions): string;
+/**
+ * Generate a contextual correlation ID
+ * Includes context information for better tracing
+ *
+ * @param context - Context information
+ * @param type - Type of correlation
+ * @param options - Optional ID generation options
+ * @returns Contextualized correlation ID
+ *
+ * @example
+ * ```typescript
+ * const correlationId = generateContextualCorrelationId({
+ *   service: 'api',
+ *   operation: 'getUserProfile'
+ * });
+ * // 'api:getUserProfile:corr_1a2b3c4d_5e6f7g8h'
+ *
+ * const networkId = generateContextualCorrelationId(
+ *   { quality: 'POOR', trigger: 'rtt' },
+ *   CORRELATION_TYPE.NETWORK
+ * );
+ * // 'POOR:rtt:net_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateContextualCorrelationId(context: Record<string, string | number | undefined>, type?: CORRELATION_TYPE | string, options?: IdGenerationOptions): string;
+/**
+ * Generate a network correlation ID
+ * Specialized for network event correlation
+ *
+ * @param options - Optional ID generation options
+ * @returns Network correlation identifier
+ *
+ * @example
+ * ```typescript
+ * const networkId = generateNetworkCorrelationId();
+ * // 'net_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateNetworkCorrelationId(options?: IdGenerationOptions): string;
+/**
+ * Generate an API correlation ID
+ * Specialized for API request correlation
+ *
+ * @param options - Optional ID generation options
+ * @returns API correlation identifier
+ *
+ * @example
+ * ```typescript
+ * const apiId = generateApiCorrelationId();
+ * // 'api_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateApiCorrelationId(options?: IdGenerationOptions): string;
+/**
+ * Generate a session correlation ID
+ * Specialized for user session correlation
+ *
+ * @param options - Optional ID generation options
+ * @returns Session correlation identifier
+ *
+ * @example
+ * ```typescript
+ * const sessionId = generateSessionCorrelationId();
+ * // 'session_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateSessionCorrelationId(options?: IdGenerationOptions): string;
+/**
+ * Generate a trace correlation ID
+ * Specialized for distributed tracing
+ *
+ * @param options - Optional ID generation options
+ * @returns Trace correlation identifier
+ *
+ * @example
+ * ```typescript
+ * const traceId = generateTraceCorrelationId();
+ * // 'trace_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateTraceCorrelationId(options?: IdGenerationOptions): string;
+/**
+ * Extract base correlation ID from contextual correlation ID
+ * Removes context and prefix to get the core ID
+ *
+ * @param contextualId - Contextual correlation ID
+ * @returns Base correlation ID
+ *
+ * @example
+ * ```typescript
+ * const baseId = extractBaseCorrelationId('api:getUserProfile:corr_1a2b3c4d_5e6f7g8h');
+ * // '1a2b3c4d_5e6f7g8h'
+ *
+ * const baseId = extractBaseCorrelationId('net_1a2b3c4d_5e6f7g8h');
+ * // '1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function extractBaseCorrelationId(contextualId: string): string;
+/**
+ * Extract correlation type from ID
+ *
+ * @param id - Correlation ID
+ * @returns Correlation type or undefined
+ *
+ * @example
+ * ```typescript
+ * const type = extractCorrelationType('net_1a2b3c4d_5e6f7g8h');
+ * // 'net'
+ *
+ * const type = extractCorrelationType('api:getUserProfile:api_1a2b3c4d_5e6f7g8h');
+ * // 'api'
+ * ```
+ */
+export declare function extractCorrelationType(id: string): CORRELATION_TYPE | undefined;
+/**
+ * Check if a string is a valid correlation ID format
+ *
+ * @param id - String to check
+ * @returns True if valid correlation ID format
+ *
+ * @example
+ * ```typescript
+ * isValidCorrelationId('corr_1a2b3c4d_5e6f7g8h'); // true
+ * isValidCorrelationId('net_1a2b3c4d_5e6f7g8h'); // true
+ * isValidCorrelationId('api:getUserProfile:api_1a2b3c4d_5e6f7g8h'); // true
+ * isValidCorrelationId('invalid'); // false
+ * ```
+ */
+export declare function isValidCorrelationId(id: string): boolean;
+/**
+ * Create a correlation ID generator with custom options
+ *
+ * @param type - Default correlation type
+ * @param defaultOptions - Default options for the generator
+ * @returns Custom correlation ID generator
+ *
+ * @example
+ * ```typescript
+ * const generateServiceCorrelationId = createCorrelationIdGenerator(
+ *   'service',
+ *   { randomLength: 12 }
+ * );
+ *
+ * const id = generateServiceCorrelationId();
+ * // 'service_1a2b3c4d_5e6f7g8h9i0j'
+ * ```
+ */
+export declare function createCorrelationIdGenerator(type?: CORRELATION_TYPE | string, defaultOptions?: IdGenerationOptions): (options?: IdGenerationOptions) => string;
+/**
+ * Link multiple correlation IDs together
+ * Useful for tracing related operations
+ *
+ * @param ids - Correlation IDs to link
+ * @param separator - Separator for linked IDs
+ * @returns Linked correlation ID
+ *
+ * @example
+ * ```typescript
+ * const linkedId = linkCorrelationIds(
+ *   'api_1a2b3c4d_5e6f7g8h',
+ *   'net_9i0j1k2l_3m4n5o6p'
+ * );
+ * // 'api_1a2b3c4d_5e6f7g8h->net_9i0j1k2l_3m4n5o6p'
+ * ```
+ */
+export declare function linkCorrelationIds(...ids: string[]): string;
+/**
+ * Extract linked correlation IDs
+ *
+ * @param linkedId - Linked correlation ID
+ * @returns Array of individual correlation IDs
+ *
+ * @example
+ * ```typescript
+ * const ids = extractLinkedCorrelationIds('api_1a2b3c4d_5e6f7g8h->net_9i0j1k2l_3m4n5o6p');
+ * // ['api_1a2b3c4d_5e6f7g8h', 'net_9i0j1k2l_3m4n5o6p']
+ * ```
+ */
+export declare function extractLinkedCorrelationIds(linkedId: string): string[];
+//# sourceMappingURL=correlation-id.d.ts.map

package/dist/api/utils/generation/correlation-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-id.d.ts","sourceRoot":"","sources":["../../../../src/api/utils/generation/correlation-id.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAAE,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AA+B9E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,GAAE,gBAAgB,GAAG,MAAiC,EAC1D,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAGR;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,EACpD,IAAI,GAAE,gBAAgB,GAAG,MAAiC,EAC1D,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CASR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAElF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAE9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAElF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAEhF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAcrE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAqB/E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAexD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,GAAE,gBAAgB,GAAG,MAAiC,EAC1D,cAAc,GAAE,mBAAwB,GACvC,CAAC,OAAO,CAAC,EAAE,mBAAmB,KAAK,MAAM,CAS3C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,CAE3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAEtE"}

package/dist/api/utils/generation/id-generator.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Base ID Generation Utilities
+ * Provides core ID generation functionality for request IDs, correlation IDs, and other identifiers
+ */
+import type { IdGenerationOptions } from '@plyaz/types/api';
+/**
+ * Generate a base unique identifier
+ * Core function used by all ID generators
+ *
+ * @param options - ID generation options
+ * @returns Generated unique identifier
+ *
+ * @example
+ * ```typescript
+ * // UUID-based ID
+ * const id = generateBaseId();
+ * // '550e8400-e29b-41d4-a716-446655440000'
+ *
+ * // Timestamp-based ID
+ * const id = generateBaseId({ useTimestamp: true });
+ * // '1a2b3c4d5e_f6g7h8i9'
+ *
+ * // With prefix
+ * const id = generateBaseId({ prefix: 'req' });
+ * // 'req_550e8400-e29b-41d4-a716-446655440000'
+ * ```
+ */
+export declare function generateBaseId(options?: IdGenerationOptions): string;
+/**
+ * Generate a contextual ID with metadata
+ * Includes context information for debugging and tracing
+ *
+ * @param context - Context object with metadata
+ * @param options - ID generation options
+ * @returns Contextualized ID
+ *
+ * @example
+ * ```typescript
+ * const id = generateContextualId({
+ *   method: 'GET',
+ *   path: '/api/users'
+ * });
+ * // 'GET:/api/users:550e8400-e29b-41d4-a716-446655440000'
+ * ```
+ */
+export declare function generateContextualId(context: Record<string, string | number | undefined>, options?: IdGenerationOptions): string;
+/**
+ * Extract base ID from a contextualized or prefixed ID
+ *
+ * @param id - Full ID with context or prefix
+ * @param options - Options for extraction
+ * @returns Base ID without context or prefix
+ *
+ * @example
+ * ```typescript
+ * const baseId = extractBaseId('req_550e8400-e29b-41d4-a716-446655440000');
+ * // '550e8400-e29b-41d4-a716-446655440000'
+ *
+ * const baseId = extractBaseId('GET:/api/users:550e8400-e29b-41d4-a716-446655440000');
+ * // '550e8400-e29b-41d4-a716-446655440000'
+ * ```
+ */
+export declare function extractBaseId(id: string, options?: {
+    separator?: string;
+    extractLast?: boolean;
+}): string;
+/**
+ * Validate ID format
+ * Checks if string matches expected ID patterns
+ *
+ * @param id - String to validate
+ * @param options - Validation options
+ * @returns True if valid ID format
+ *
+ * @example
+ * ```typescript
+ * isValidId('550e8400-e29b-41d4-a716-446655440000'); // true (UUID)
+ * isValidId('req_123456'); // true (prefixed)
+ * isValidId('net_1a2b3c_4d5e6f'); // true (timestamp)
+ * isValidId('invalid'); // false
+ * ```
+ */
+export declare function isValidId(id: string, options?: {
+    allowUuid?: boolean;
+    allowTimestamp?: boolean;
+    allowPrefix?: boolean;
+    minLength?: number;
+}): boolean;
+/**
+ * Parse an ID to extract its components
+ *
+ * @param id - ID to parse
+ * @param options - Parsing options
+ * @returns Parsed components
+ *
+ * @example
+ * ```typescript
+ * const parts = parseId('req_123_abc');
+ * // { prefix: 'req', core: '123', suffix: 'abc' }
+ *
+ * const parts = parseId('GET:/api/users:550e8400');
+ * // { context: 'GET:/api/users', core: '550e8400' }
+ * ```
+ */
+export declare function parseId(id: string, options?: {
+    separator?: string;
+}): {
+    prefix?: string;
+    core: string;
+    suffix?: string;
+    context?: string;
+    full: string;
+};
+/**
+ * Create a custom ID generator with preset options
+ *
+ * @param defaultOptions - Default options for the generator
+ * @returns Custom ID generator function
+ *
+ * @example
+ * ```typescript
+ * const generateRequestId = createIdGenerator({ prefix: 'req' });
+ * const generateCorrelationId = createIdGenerator({
+ *   prefix: 'corr',
+ *   useTimestamp: true
+ * });
+ *
+ * const reqId = generateRequestId(); // 'req_550e8400-...'
+ * const corrId = generateCorrelationId(); // 'corr_1a2b3c_4d5e6f'
+ * ```
+ */
+export declare function createIdGenerator(defaultOptions?: IdGenerationOptions): (options?: IdGenerationOptions) => string;
+//# sourceMappingURL=id-generator.d.ts.map

package/dist/api/utils/generation/id-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generator.d.ts","sourceRoot":"","sources":["../../../../src/api/utils/generation/id-generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AA4B5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAoCxE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,EACpD,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAgBR;AAwDD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1D,MAAM,CAQR;AAmGD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CACvB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GACL,OAAO,CAST;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACnC;IACD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAoCA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,cAAc,GAAE,mBAAwB,GACvC,CAAC,OAAO,CAAC,EAAE,mBAAmB,KAAK,MAAM,CAI3C"}

package/dist/api/utils/generation/request-id.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Request ID Generation Utilities
+ * Provides request-specific ID generation using the base ID generator
+ */
+import type { IdGenerationOptions } from '@plyaz/types/api';
+/**
+ * Generate a unique request ID
+ * Uses UUID format with 'req' prefix for guaranteed uniqueness
+ *
+ * @param options - Optional ID generation options to override defaults
+ * @returns Unique request identifier
+ *
+ * @example
+ * ```typescript
+ * const requestId = generateRequestId();
+ * // 'req_550e8400-e29b-41d4-a716-446655440000'
+ * ```
+ */
+export declare function generateRequestId(options?: IdGenerationOptions): string;
+/**
+ * Generate a request ID with context
+ * Includes method and URL information for debugging
+ *
+ * @param method - HTTP method
+ * @param url - Request URL
+ * @param options - Optional ID generation options
+ * @returns Contextualized request ID
+ *
+ * @example
+ * ```typescript
+ * const requestId = generateContextualRequestId('GET', '/api/users');
+ * // 'GET:/api/users:req_550e8400-e29b-41d4-a716-446655440000'
+ *
+ * const requestId = generateContextualRequestId('POST', '/api/data', {
+ *   useTimestamp: true
+ * });
+ * // 'POST:/api/data:req_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateContextualRequestId(method?: string, url?: string, options?: IdGenerationOptions): string;
+/**
+ * Extract base request ID from contextual request ID
+ * Removes context and prefix to get the core ID
+ *
+ * @param contextualId - Contextual request ID
+ * @returns Base request ID
+ *
+ * @example
+ * ```typescript
+ * const baseId = extractBaseRequestId('GET:/api/users:req_550e8400-e29b-41d4-a716-446655440000');
+ * // '550e8400-e29b-41d4-a716-446655440000'
+ *
+ * const baseId = extractBaseRequestId('req_550e8400-e29b-41d4-a716-446655440000');
+ * // '550e8400-e29b-41d4-a716-446655440000'
+ * ```
+ */
+export declare function extractBaseRequestId(contextualId: string): string;
+/**
+ * Check if a string is a valid request ID format
+ *
+ * @param id - String to check
+ * @returns True if valid request ID format
+ *
+ * @example
+ * ```typescript
+ * isValidRequestId('req_550e8400-e29b-41d4-a716-446655440000'); // true
+ * isValidRequestId('GET:/api:req_550e8400-e29b-41d4-a716-446655440000'); // true
+ * isValidRequestId('550e8400-e29b-41d4-a716-446655440000'); // true (UUID)
+ * isValidRequestId('invalid'); // false
+ * ```
+ */
+export declare function isValidRequestId(id: string): boolean;
+/**
+ * Generate a short request ID for logging
+ * Useful when you need a shorter identifier
+ *
+ * @param options - Optional ID generation options
+ * @returns Short request identifier
+ *
+ * @example
+ * ```typescript
+ * const shortId = generateShortRequestId();
+ * // 'req_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function generateShortRequestId(options?: IdGenerationOptions): string;
+/**
+ * Create a request ID generator with custom options
+ * Useful for creating specialized request ID generators
+ *
+ * @param defaultOptions - Default options for the generator
+ * @returns Custom request ID generator
+ *
+ * @example
+ * ```typescript
+ * const generateApiRequestId = createRequestIdGenerator({
+ *   prefix: 'api-req',
+ *   useTimestamp: true
+ * });
+ *
+ * const id = generateApiRequestId();
+ * // 'api-req_1a2b3c4d_5e6f7g8h'
+ * ```
+ */
+export declare function createRequestIdGenerator(defaultOptions?: IdGenerationOptions): (options?: IdGenerationOptions) => string;
+//# sourceMappingURL=request-id.d.ts.map

package/dist/api/utils/generation/request-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-id.d.ts","sourceRoot":"","sources":["../../../../src/api/utils/generation/request-id.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAiB5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAEvE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,CAAC,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAYR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAUjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAQpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,MAAM,CAM5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,GAAE,mBAAwB,GACvC,CAAC,OAAO,CAAC,EAAE,mBAAmB,KAAK,MAAM,CAK3C"}

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

@@ -0,0 +1,19 @@
+/**
+ * API Utilities
+ * Collection of utility functions for API operations
+ */
+export * from './time';
+export * from './environment';
+export * from './generation/id-generator';
+export * from './generation/request-id';
+export * from './generation/correlation-id';
+export * from './object-merge';
+export * from './async-control';
+export * from './interval-manager';
+export * from './type-guards';
+export * from './math';
+export * from './object';
+export * from './json';
+export * from './validation';
+export * from './string';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,cAAc,QAAQ,CAAC;AAGvB,cAAc,eAAe,CAAC;AAG9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAG5C,cAAc,gBAAgB,CAAC;AAG/B,cAAc,iBAAiB,CAAC;AAGhC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,eAAe,CAAC;AAG9B,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC;AAGzB,cAAc,QAAQ,CAAC;AAGvB,cAAc,cAAc,CAAC;AAG7B,cAAc,UAAU,CAAC"}

package/dist/api/utils/interval-manager.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Interval Management Utilities
+ * Utilities for managing setInterval/clearInterval operations with cleanup
+ */
+/**
+ * Interval manager for tracking and cleaning up intervals
+ */
+export declare class IntervalManager {
+    private intervals;
+    /**
+     * Create and track a new interval
+     *
+     * @param callback - Function to execute
+     * @param delay - Delay between executions
+     * @returns Interval ID
+     */
+    setInterval(callback: () => void, delay: number): ReturnType<typeof setInterval>;
+    /**
+     * Clear a specific interval
+     *
+     * @param id - Interval ID to clear
+     */
+    clearInterval(id: ReturnType<typeof setInterval>): void;
+    /**
+     * Clear all managed intervals
+     */
+    clearAll(): void;
+    /**
+     * Get count of active intervals
+     */
+    get count(): number;
+}
+/**
+ * Create a managed interval that auto-cleans up
+ *
+ * @param callback - Function to execute
+ * @param delay - Delay between executions
+ * @returns Object with clear method
+ *
+ * @example
+ * ```typescript
+ * const timer = createManagedInterval(() => {
+ *   console.log('tick');
+ * }, 1000);
+ *
+ * // Later: clean up
+ * timer.clear();
+ * ```
+ */
+export declare function createManagedInterval(callback: () => void, delay: number): {
+    clear: () => void;
+    id: ReturnType<typeof setInterval>;
+};
+/**
+ * Create an interval that automatically stops after a maximum number of executions
+ *
+ * @param callback - Function to execute
+ * @param delay - Delay between executions
+ * @param maxExecutions - Maximum number of times to execute
+ * @returns Object with clear method
+ *
+ * @example
+ * ```typescript
+ * const timer = createLimitedInterval(() => {
+ *   console.log('tick');
+ * }, 1000, 5); // Will execute 5 times then stop
+ * ```
+ */
+export declare function createLimitedInterval(callback: () => void, delay: number, maxExecutions: number): {
+    clear: () => void;
+    id: ReturnType<typeof setInterval>;
+};
+/**
+ * Create an interval that stops when a condition becomes true
+ *
+ * @param callback - Function to execute
+ * @param delay - Delay between executions
+ * @param stopCondition - Function that returns true when interval should stop
+ * @returns Object with clear method
+ *
+ * @example
+ * ```typescript
+ * let counter = 0;
+ * const timer = createConditionalInterval(() => {
+ *   counter++;
+ *   console.log(`Count: ${counter}`);
+ * }, 1000, () => counter >= 10); // Stops when counter reaches 10
+ * ```
+ */
+export declare function createConditionalInterval(callback: () => void, delay: number, stopCondition: () => boolean): {
+    clear: () => void;
+    id: ReturnType<typeof setInterval>;
+};
+//# sourceMappingURL=interval-manager.d.ts.map

package/dist/api/utils/interval-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval-manager.d.ts","sourceRoot":"","sources":["../../../src/api/utils/interval-manager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAA6C;IAE9D;;;;;;OAMG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC;IAMhF;;;;OAIG;IACH,aAAa,CAAC,EAAE,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,GAAG,IAAI;IAOvD;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;CACF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,IAAI,EACpB,KAAK,EAAE,MAAM,GACZ;IACD,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,EAAE,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CACpC,CAOA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,IAAI,EACpB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB;IACD,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,EAAE,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CACpC,CAsCA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,IAAI,EACpB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,OAAO,GAC3B;IACD,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,EAAE,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CACpC,CAiBA"}

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

@@ -0,0 +1,98 @@
+/**
+ * JSON Utilities
+ * Safe JSON operations with error handling and type support
+ */
+/**
+ * Safely parse JSON with error handling
+ *
+ * @param json - JSON string to parse
+ * @param fallback - Fallback value if parsing fails
+ * @returns Parsed object or fallback
+ *
+ * @example
+ * ```typescript
+ * const data = safeParseJSON('{"name": "test"}', {});
+ * const invalid = safeParseJSON('invalid', null); // Returns null
+ * ```
+ */
+export declare function safeParseJSON<T = unknown>(json: string, fallback: T): T;
+/**
+ * Safely stringify object with error handling
+ *
+ * @param value - Value to stringify
+ * @param fallback - Fallback string if stringify fails
+ * @returns JSON string or fallback
+ *
+ * @example
+ * ```typescript
+ * const str = safeStringify({ name: 'test' }, '{}');
+ * const circular = safeStringify(circularObj, 'null'); // Returns 'null'
+ * ```
+ */
+export declare function safeStringify<T>(value: T, fallback?: string): string;
+/**
+ * Pretty print JSON with indentation
+ *
+ * @param value - Value to stringify
+ * @param space - Number of spaces for indentation
+ * @returns Formatted JSON string
+ */
+export declare function prettyStringify<T>(value: T, space?: number): string;
+/**
+ * Deep clone object using JSON (simple objects only)
+ *
+ * @param value - Value to clone
+ * @returns Cloned value
+ *
+ * @example
+ * ```typescript
+ * const original = { name: 'test', data: [1, 2, 3] };
+ * const clone = jsonClone(original);
+ * ```
+ */
+export declare function jsonClone<T>(value: T): T;
+/**
+ * Check if string is valid JSON
+ *
+ * @param json - String to validate
+ * @returns True if valid JSON
+ */
+export declare function isValidJSON(json: string): boolean;
+/**
+ * Get JSON string size in bytes
+ *
+ * @param value - Value to measure
+ * @returns Size in bytes
+ */
+export declare function getJSONSize<T>(value: T): number;
+/**
+ * Truncate JSON string to maximum length
+ *
+ * @param value - Value to stringify and truncate
+ * @param maxLength - Maximum length of resulting string
+ * @param suffix - Suffix to add when truncated
+ * @returns Truncated JSON string
+ *
+ * @example
+ * ```typescript
+ * const data = { name: 'very long name', data: [...] };
+ * const short = truncateJSON(data, 50, '...[truncated]');
+ * ```
+ */
+export declare function truncateJSON<T>(value: T, maxLength: number, suffix?: string): string;
+/**
+ * Compare two values by their JSON representation
+ *
+ * @param a - First value
+ * @param b - Second value
+ * @returns True if JSON representations are equal
+ */
+export declare function jsonEquals<T>(a: T, b: T): boolean;
+/**
+ * Remove circular references from object before JSON serialization
+ *
+ * @param obj - Object to clean
+ * @returns Object safe for JSON.stringify
+ */
+export declare function removeCircularReferences<T>(obj: T): T;
+//# sourceMappingURL=json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/api/utils/json.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAMvE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,SAAS,GAAG,MAAM,CAMpE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,SAAI,GAAG,MAAM,CAM9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAOxC;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOjD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAM/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,SAAmB,GAAG,MAAM,CAU9F;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAMjD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAkBrD"}