@lgriffin/esi.ts 1.0.0 → 4.0.0

package/dist/core/cache/ETagCacheManager.d.ts

@@ -0,0 +1,71 @@
+import { ICache, CacheEntry } from './ICache';
+export type { CacheEntry } from './ICache';
+export interface ETagCacheConfig {
+    maxEntries?: number;
+    defaultTtl?: number;
+    cleanupInterval?: number;
+}
+export declare class ETagCacheManager implements ICache {
+    private cache;
+    private config;
+    private cleanupTimer?;
+    private hits;
+    private misses;
+    constructor(config?: ETagCacheConfig);
+    /**
+     * Get cached data if ETag matches
+     */
+    get(url: string): CacheEntry | null;
+    /**
+     * Get ETag for a URL (for If-None-Match header)
+     */
+    getETag(url: string): string | null;
+    /**
+     * Set cache entry
+     */
+    set(url: string, etag: string, data: unknown, headers: Record<string, string>, customTtl?: number): void;
+    /**
+     * Check if cached data exists and is valid
+     */
+    has(url: string): boolean;
+    /**
+     * Clear specific cache entry
+     */
+    delete(url: string): boolean;
+    /**
+     * Delete all cache entries whose URL contains the given path segment
+     */
+    deleteByPath(pathSegment: string): number;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        totalEntries: number;
+        maxEntries: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+        oldestEntry: number | null;
+        newestEntry: number | null;
+    };
+    /**
+     * Update cache configuration
+     */
+    updateConfig(newConfig: Partial<ETagCacheConfig>): void;
+    /**
+     * Cleanup expired entries
+     */
+    cleanup(): number;
+    /**
+     * Shutdown cache manager
+     */
+    shutdown(): void;
+    private isExpired;
+    private evictOldest;
+    private startCleanupTimer;
+}
+//# sourceMappingURL=ETagCacheManager.d.ts.map

package/dist/core/cache/ETagCacheManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ETagCacheManager.d.ts","sourceRoot":"","sources":["../../../src/core/cache/ETagCacheManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE9C,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,gBAAiB,YAAW,MAAM;IAC7C,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,YAAY,CAAC,CAAiB;IACtC,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,MAAM,CAAa;gBAEf,MAAM,GAAE,eAAoB;IAaxC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAoBnC;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKnC;;OAEG;IACH,GAAG,CACD,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI;IAkBP;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKzB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B;;OAEG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAczC;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,QAAQ,IAAI;QACV,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B;IAoBD;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IAKvD;;OAEG;IACH,OAAO,IAAI,MAAM;IAiBjB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAOhB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,iBAAiB;CAO1B"}

package/dist/core/cache/ETagCacheManager.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ETagCacheManager = void 0;
+const loggerUtil_1 = require("../logger/loggerUtil");
+class ETagCacheManager {
+    cache = new Map();
+    config;
+    cleanupTimer;
+    hits = 0;
+    misses = 0;
+    constructor(config = {}) {
+        this.config = {
+            maxEntries: config.maxEntries ?? 1000,
+            defaultTtl: config.defaultTtl ?? 5 * 60 * 1000, // 5 minutes default
+            cleanupInterval: config.cleanupInterval ?? 60 * 1000, // 1 minute cleanup
+        };
+        this.startCleanupTimer();
+        (0, loggerUtil_1.logInfo)(`ETag cache manager initialized with ${this.config.maxEntries} max entries`);
+    }
+    /**
+     * Get cached data if ETag matches
+     */
+    get(url) {
+        const entry = this.cache.get(url);
+        if (!entry) {
+            this.misses++;
+            return null;
+        }
+        if (this.isExpired(entry)) {
+            this.cache.delete(url);
+            this.misses++;
+            (0, loggerUtil_1.logDebug)(`Cache entry expired for ${url}`);
+            return null;
+        }
+        this.hits++;
+        (0, loggerUtil_1.logDebug)(`Cache hit for ${url} with ETag ${entry.etag}`);
+        return entry;
+    }
+    /**
+     * Get ETag for a URL (for If-None-Match header)
+     */
+    getETag(url) {
+        const entry = this.get(url);
+        return entry ? entry.etag : null;
+    }
+    /**
+     * Set cache entry
+     */
+    set(url, etag, data, headers, customTtl) {
+        // Remove oldest entries if cache is full
+        if (this.cache.size >= this.config.maxEntries) {
+            this.evictOldest();
+        }
+        const entry = {
+            etag,
+            data,
+            headers,
+            timestamp: Date.now(),
+            ttl: customTtl ?? this.config.defaultTtl,
+        };
+        this.cache.set(url, entry);
+        (0, loggerUtil_1.logDebug)(`Cached response for ${url} with ETag ${etag}`);
+    }
+    /**
+     * Check if cached data exists and is valid
+     */
+    has(url) {
+        const entry = this.cache.get(url);
+        return entry !== undefined && !this.isExpired(entry);
+    }
+    /**
+     * Clear specific cache entry
+     */
+    delete(url) {
+        return this.cache.delete(url);
+    }
+    /**
+     * Delete all cache entries whose URL contains the given path segment
+     */
+    deleteByPath(pathSegment) {
+        let count = 0;
+        for (const key of this.cache.keys()) {
+            if (key.includes(pathSegment)) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        if (count > 0) {
+            (0, loggerUtil_1.logDebug)(`Invalidated ${count} cache entries matching ${pathSegment}`);
+        }
+        return count;
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+        (0, loggerUtil_1.logInfo)('ETag cache cleared');
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        let oldest = Infinity;
+        let newest = -Infinity;
+        for (const entry of this.cache.values()) {
+            if (entry.timestamp < oldest)
+                oldest = entry.timestamp;
+            if (entry.timestamp > newest)
+                newest = entry.timestamp;
+        }
+        const total = this.hits + this.misses;
+        return {
+            totalEntries: this.cache.size,
+            maxEntries: this.config.maxEntries,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0,
+            oldestEntry: this.cache.size > 0 ? oldest : null,
+            newestEntry: this.cache.size > 0 ? newest : null,
+        };
+    }
+    /**
+     * Update cache configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        (0, loggerUtil_1.logInfo)('ETag cache configuration updated');
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanup() {
+        const beforeSize = this.cache.size;
+        for (const [url, entry] of this.cache.entries()) {
+            if (this.isExpired(entry)) {
+                this.cache.delete(url);
+            }
+        }
+        const cleanedCount = beforeSize - this.cache.size;
+        if (cleanedCount > 0) {
+            (0, loggerUtil_1.logDebug)(`Cleaned up ${cleanedCount} expired cache entries`);
+        }
+        return cleanedCount;
+    }
+    /**
+     * Shutdown cache manager
+     */
+    shutdown() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        (0, loggerUtil_1.logInfo)('ETag cache manager shut down');
+    }
+    isExpired(entry) {
+        if (!entry.ttl)
+            return false;
+        return Date.now() - entry.timestamp > entry.ttl;
+    }
+    evictOldest() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+            (0, loggerUtil_1.logDebug)(`Evicted oldest cache entry: ${oldestKey}`);
+        }
+    }
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.config.cleanupInterval);
+        // Don't prevent process exit (important for test runners and CLI tools)
+        this.cleanupTimer.unref();
+    }
+}
+exports.ETagCacheManager = ETagCacheManager;

package/dist/core/cache/ICache.d.ts

@@ -0,0 +1,27 @@
+export interface CacheEntry {
+    etag: string;
+    data: unknown;
+    headers: Record<string, string>;
+    timestamp: number;
+    ttl?: number;
+}
+export interface ICache {
+    get(url: string): CacheEntry | null;
+    getETag(url: string): string | null;
+    set(url: string, etag: string, data: unknown, headers: Record<string, string>, customTtl?: number): void;
+    has(url: string): boolean;
+    delete(url: string): boolean;
+    deleteByPath(pathSegment: string): number;
+    clear(): void;
+    getStats(): {
+        totalEntries: number;
+        maxEntries: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+        oldestEntry: number | null;
+        newestEntry: number | null;
+    };
+    shutdown(): void;
+}
+//# sourceMappingURL=ICache.d.ts.map

package/dist/core/cache/ICache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICache.d.ts","sourceRoot":"","sources":["../../../src/core/cache/ICache.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,MAAM;IACrB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IACpC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,GAAG,CACD,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAAC;IACR,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1C,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,IAAI;QACV,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,CAAC;IACF,QAAQ,IAAI,IAAI,CAAC;CAClB"}

package/dist/core/cache/ICache.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/circuitBreaker/CircuitBreaker.d.ts

@@ -0,0 +1,39 @@
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerConfig {
+    failureThreshold?: number;
+    resetTimeoutMs?: number;
+    halfOpenMaxAttempts?: number;
+    staleThresholdMs?: number;
+}
+export declare class CircuitBreaker {
+    private circuits;
+    private readonly failureThreshold;
+    private readonly resetTimeoutMs;
+    private readonly halfOpenMaxAttempts;
+    private readonly staleThresholdMs;
+    constructor(config?: CircuitBreakerConfig);
+    private getKey;
+    private getOrCreate;
+    checkCircuit(endpoint: string): void;
+    recordSuccess(endpoint: string): void;
+    recordFailure(endpoint: string, statusCode: number): void;
+    getState(endpoint: string): CircuitState;
+    getStats(): {
+        totalCircuits: number;
+        openCircuits: number;
+        circuits: Record<string, {
+            state: CircuitState;
+            failures: number;
+        }>;
+    };
+    reset(endpoint?: string): void;
+    cleanup(): number;
+    shutdown(): void;
+}
+export declare class CircuitOpenError extends Error {
+    readonly endpoint: string;
+    readonly failures: number;
+    readonly retryAfterMs: number;
+    constructor(endpoint: string, failures: number, retryAfterMs: number);
+}
+//# sourceMappingURL=CircuitBreaker.d.ts.map

package/dist/core/circuitBreaker/CircuitBreaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircuitBreaker.d.ts","sourceRoot":"","sources":["../../../src/core/circuitBreaker/CircuitBreaker.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AASD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;gBAE9B,MAAM,GAAE,oBAAyB;IAO7C,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,WAAW;IAcnB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IA0BpC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAcrC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAyBzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY;IAexC,QAAQ,IAAI;QACV,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,KAAK,EAAE,YAAY,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACrE;IAmBD,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ9B,OAAO,IAAI,MAAM;IAoBjB,QAAQ,IAAI,IAAI;CAGjB;AAED,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAElB,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CASrE"}

package/dist/core/circuitBreaker/CircuitBreaker.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitOpenError = exports.CircuitBreaker = void 0;
+const loggerUtil_1 = require("../logger/loggerUtil");
+class CircuitBreaker {
+    circuits = new Map();
+    failureThreshold;
+    resetTimeoutMs;
+    halfOpenMaxAttempts;
+    staleThresholdMs;
+    constructor(config = {}) {
+        this.failureThreshold = config.failureThreshold ?? 5;
+        this.resetTimeoutMs = config.resetTimeoutMs ?? 30_000;
+        this.halfOpenMaxAttempts = config.halfOpenMaxAttempts ?? 1;
+        this.staleThresholdMs = config.staleThresholdMs ?? 3_600_000;
+    }
+    getKey(endpoint) {
+        return endpoint.split('?')[0];
+    }
+    getOrCreate(key) {
+        let record = this.circuits.get(key);
+        if (!record) {
+            record = {
+                state: 'closed',
+                failures: 0,
+                lastFailureTime: 0,
+                halfOpenAttempts: 0,
+            };
+            this.circuits.set(key, record);
+        }
+        return record;
+    }
+    checkCircuit(endpoint) {
+        const key = this.getKey(endpoint);
+        const record = this.getOrCreate(key);
+        if (record.state === 'closed')
+            return;
+        if (record.state === 'open') {
+            const elapsed = Date.now() - record.lastFailureTime;
+            if (elapsed >= this.resetTimeoutMs) {
+                record.state = 'half-open';
+                record.halfOpenAttempts = 0;
+                (0, loggerUtil_1.logInfo)(`Circuit half-open for ${key}, allowing probe request`);
+                return;
+            }
+            const remainingMs = this.resetTimeoutMs - elapsed;
+            throw new CircuitOpenError(key, record.failures, remainingMs);
+        }
+        if (record.state === 'half-open') {
+            if (record.halfOpenAttempts >= this.halfOpenMaxAttempts) {
+                throw new CircuitOpenError(key, record.failures, this.resetTimeoutMs);
+            }
+            record.halfOpenAttempts++;
+        }
+    }
+    recordSuccess(endpoint) {
+        const key = this.getKey(endpoint);
+        const record = this.circuits.get(key);
+        if (!record)
+            return;
+        if (record.state === 'half-open') {
+            (0, loggerUtil_1.logInfo)(`Circuit closed for ${key} after successful probe`);
+        }
+        record.state = 'closed';
+        record.failures = 0;
+        record.halfOpenAttempts = 0;
+    }
+    recordFailure(endpoint, statusCode) {
+        if (statusCode < 500)
+            return;
+        const key = this.getKey(endpoint);
+        const record = this.getOrCreate(key);
+        record.failures++;
+        record.lastFailureTime = Date.now();
+        if (record.state === 'half-open') {
+            record.state = 'open';
+            (0, loggerUtil_1.logWarn)(`Circuit re-opened for ${key} after failed probe (${record.failures} failures)`);
+            return;
+        }
+        if (record.failures >= this.failureThreshold) {
+            record.state = 'open';
+            (0, loggerUtil_1.logWarn)(`Circuit opened for ${key} after ${record.failures} consecutive 5xx failures`);
+        }
+    }
+    getState(endpoint) {
+        const key = this.getKey(endpoint);
+        const record = this.circuits.get(key);
+        if (!record)
+            return 'closed';
+        if (record.state === 'open') {
+            const elapsed = Date.now() - record.lastFailureTime;
+            if (elapsed >= this.resetTimeoutMs) {
+                return 'half-open';
+            }
+        }
+        return record.state;
+    }
+    getStats() {
+        const circuits = {};
+        let openCircuits = 0;
+        for (const [key, record] of this.circuits.entries()) {
+            const state = this.getState(key);
+            // eslint-disable-next-line security/detect-object-injection
+            circuits[key] = { state, failures: record.failures };
+            if (state === 'open')
+                openCircuits++;
+        }
+        return {
+            totalCircuits: this.circuits.size,
+            openCircuits,
+            circuits,
+        };
+    }
+    reset(endpoint) {
+        if (endpoint) {
+            this.circuits.delete(this.getKey(endpoint));
+        }
+        else {
+            this.circuits.clear();
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, record] of this.circuits.entries()) {
+            if (record.state === 'closed' &&
+                record.failures === 0 &&
+                record.lastFailureTime > 0 &&
+                now - record.lastFailureTime > this.staleThresholdMs) {
+                this.circuits.delete(key);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            (0, loggerUtil_1.logInfo)(`Circuit breaker cleanup: removed ${cleaned} stale circuits`);
+        }
+        return cleaned;
+    }
+    shutdown() {
+        this.circuits.clear();
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+class CircuitOpenError extends Error {
+    endpoint;
+    failures;
+    retryAfterMs;
+    constructor(endpoint, failures, retryAfterMs) {
+        super(`Circuit breaker open for ${endpoint} after ${failures} failures (retry after ${Math.ceil(retryAfterMs / 1000)}s)`);
+        this.name = 'CircuitOpenError';
+        this.endpoint = endpoint;
+        this.failures = failures;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.CircuitOpenError = CircuitOpenError;

package/dist/core/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const PACKAGE_NAME = "esi.ts";
+export declare const PACKAGE_VERSION = "3.4.0";
+export declare const USER_AGENT = "esi.ts/3.4.0";
+export declare const COMPATIBILITY_DATE = "2025-12-16";
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,WAAW,CAAC;AACrC,eAAO,MAAM,eAAe,UAAU,CAAC;AACvC,eAAO,MAAM,UAAU,iBAAuC,CAAC;AAC/D,eAAO,MAAM,kBAAkB,eAAe,CAAC"}

package/dist/core/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPATIBILITY_DATE = exports.USER_AGENT = exports.PACKAGE_VERSION = exports.PACKAGE_NAME = void 0;
+exports.PACKAGE_NAME = 'esi.ts';
+exports.PACKAGE_VERSION = '3.4.0';
+exports.USER_AGENT = `${exports.PACKAGE_NAME}/${exports.PACKAGE_VERSION}`;
+exports.COMPATIBILITY_DATE = '2025-12-16';

package/dist/core/container/Container.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.container = exports.Container = exports.CircularDependencyError = void 0;
+exports.Injectable = Injectable;
+exports.Inject = Inject;
+class CircularDependencyError extends Error {
+    constructor(dependencyChain) {
+        super(`Circular dependency detected: ${dependencyChain.join(' -> ')}`);
+        this.name = 'CircularDependencyError';
+    }
+}
+exports.CircularDependencyError = CircularDependencyError;
+class Container {
+    constructor(config = {}) {
+        this.dependencies = new Map();
+        this.singletons = new Map();
+        this.resolutionStack = [];
+        this.config = Object.assign({ enableLogging: false, enableCircularDependencyDetection: true }, config);
+    }
+    /**
+     * Register a factory function for a dependency
+     */
+    register(token, factory, singleton = false) {
+        if (this.config.enableLogging) {
+            console.log(`Registering dependency: ${token} (singleton: ${singleton})`);
+        }
+        this.dependencies.set(token, factory);
+        if (singleton) {
+            // Pre-resolve singleton to catch errors early
+            this.resolve(token);
+        }
+        return this;
+    }
+    /**
+     * Register a singleton dependency
+     */
+    registerSingleton(token, factory) {
+        return this.register(token, factory, true);
+    }
+    /**
+     * Register an instance directly as a singleton
+     */
+    registerInstance(token, instance) {
+        this.singletons.set(token, instance);
+        return this;
+    }
+    /**
+     * Resolve a dependency by token
+     */
+    resolve(token) {
+        // Check if it's already a singleton instance
+        if (this.singletons.has(token)) {
+            return this.singletons.get(token);
+        }
+        // Get the factory
+        const factory = this.dependencies.get(token);
+        if (!factory) {
+            throw new Error(`Dependency '${token}' not found. Available dependencies: ${Array.from(this.dependencies.keys()).join(', ')}`);
+        }
+        // Check for circular dependencies
+        if (this.config.enableCircularDependencyDetection && this.resolutionStack.includes(token)) {
+            throw new CircularDependencyError([...this.resolutionStack, token]);
+        }
+        // Add to resolution stack
+        this.resolutionStack.push(token);
+        try {
+            const instance = factory();
+            // Store as singleton if it was registered as one
+            if (this.isSingleton(token)) {
+                this.singletons.set(token, instance);
+            }
+            return instance;
+        }
+        finally {
+            // Remove from resolution stack
+            this.resolutionStack.pop();
+        }
+    }
+    /**
+     * Check if a dependency is registered
+     */
+    has(token) {
+        return this.dependencies.has(token) || this.singletons.has(token);
+    }
+    /**
+     * Remove a dependency
+     */
+    remove(token) {
+        const hadDependency = this.dependencies.delete(token);
+        const hadSingleton = this.singletons.delete(token);
+        return hadDependency || hadSingleton;
+    }
+    /**
+     * Clear all dependencies
+     */
+    clear() {
+        this.dependencies.clear();
+        this.singletons.clear();
+        this.resolutionStack = [];
+    }
+    /**
+     * Get all registered dependency tokens
+     */
+    getRegisteredTokens() {
+        const dependencyTokens = Array.from(this.dependencies.keys());
+        const singletonTokens = Array.from(this.singletons.keys());
+        return [...new Set([...dependencyTokens, ...singletonTokens])];
+    }
+    /**
+     * Create a child container that inherits from this one
+     */
+    createChild() {
+        const child = new Container(this.config);
+        // Copy dependencies (not instances)
+        for (const [token, factory] of this.dependencies) {
+            child.dependencies.set(token, factory);
+        }
+        return child;
+    }
+    isSingleton(token) {
+        // Check if the token was registered with singleton behavior
+        // This is determined by checking if resolve was called during registration
+        return false; // For now, we'll manage this manually
+    }
+}
+exports.Container = Container;
+// Global container instance
+exports.container = new Container({
+    enableLogging: process.env.NODE_ENV === 'development',
+    enableCircularDependencyDetection: true
+});
+// Dependency injection decorators (if using experimental decorators)
+function Injectable(token) {
+    return function (constructor) {
+        const dependencyToken = token || constructor.name;
+        exports.container.register(dependencyToken, () => new constructor());
+        return constructor;
+    };
+}
+function Inject(token) {
+    return function (target, propertyKey, parameterIndex) {
+        // This would require reflect-metadata for full implementation
+        // For now, it's a placeholder for future enhancement
+    };
+}