backtest-kit 1.5.36 → 1.5.37

package/build/index.cjs

@@ -18426,7 +18426,8 @@ class ExchangeUtils {
  */
 const Exchange = new ExchangeUtils();
 
-const CACHE_METHOD_NAME_CLEAR = "CacheUtils.clear";
+const CACHE_METHOD_NAME_FLUSH = "CacheUtils.flush";
+const CACHE_METHOD_NAME_CLEAR = "CacheInstance.clear";
 const CACHE_METHOD_NAME_RUN = "CacheInstance.run";
 const CACHE_METHOD_NAME_FN = "CacheUtils.fn";
 const INTERVAL_MINUTES = {
@@ -18506,14 +18507,16 @@ class CacheInstance {
         this.run = (...args) => {
             backtest$1.loggerService.debug(CACHE_METHOD_NAME_RUN, { args });
             const step = INTERVAL_MINUTES[this.interval];
-            if (!step) {
-                throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
-            }
-            if (!MethodContextService.hasContext()) {
-                throw new Error("CacheInstance run requires method context");
-            }
-            if (!ExecutionContextService.hasContext()) {
-                throw new Error("CacheInstance run requires execution context");
+            {
+                if (!MethodContextService.hasContext()) {
+                    throw new Error("CacheInstance run requires method context");
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error("CacheInstance run requires execution context");
+                }
+                if (!step) {
+                    throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
+                }
             }
             const key = createKey(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
             const currentWhen = backtest$1.executionContextService.context.when;
@@ -18532,6 +18535,30 @@ class CacheInstance {
             this._cacheMap.set(key, newCache);
             return newCache;
         };
+        /**
+         * Clear cached value for current execution context.
+         *
+         * Removes the cached entry for the current strategy/exchange/mode combination
+         * from this instance's cache map. The next `run()` call will recompute the value.
+         *
+         * Requires active execution context (strategy, exchange, backtest mode) and method context
+         * to determine which cache entry to clear.
+         *
+         * @example
+         * ```typescript
+         * const instance = new CacheInstance(calculateIndicator, "1h");
+         * const result1 = instance.run("BTCUSDT", 14); // Computed
+         * const result2 = instance.run("BTCUSDT", 14); // Cached
+         *
+         * instance.clear(); // Clear cache for current context
+         *
+         * const result3 = instance.run("BTCUSDT", 14); // Recomputed
+         * ```
+         */
+        this.clear = () => {
+            const key = createKey(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
+            this._cacheMap.delete(key);
+        };
     }
 }
 /**
@@ -18580,45 +18607,85 @@ class CacheUtils {
          * ```
          */
         this.fn = (run, context) => {
-            backtest$1.loggerService.debug(CACHE_METHOD_NAME_FN, {
+            backtest$1.loggerService.info(CACHE_METHOD_NAME_FN, {
                 context,
             });
-            return (...args) => {
+            const wrappedFn = (...args) => {
                 const instance = this._getInstance(run, context.interval);
                 return instance.run(...args).value;
             };
+            return wrappedFn;
         };
         /**
-         * Clear cached instances for specific function or all cached functions.
+         * Flush (remove) cached CacheInstance for a specific function or all functions.
          *
-         * This method delegates to the memoized `_getInstance` function's clear method,
-         * which removes cached CacheInstance objects. When a CacheInstance is removed,
-         * all cached function results for that instance are also discarded.
+         * This method removes CacheInstance objects from the internal memoization cache.
+         * When a CacheInstance is flushed, all cached results across all contexts
+         * (all strategy/exchange/mode combinations) for that function are discarded.
          *
          * Use cases:
-         * - Clear cache for a specific function when its implementation changes
-         * - Free memory by removing unused cached instances
-         * - Reset all caches when switching contexts (e.g., between different backtests)
+         * - Remove specific function's CacheInstance when implementation changes
+         * - Free memory by removing unused CacheInstances
+         * - Reset all CacheInstances when switching between different test scenarios
+         *
+         * Note: This is different from `clear()` which only removes cached values
+         * for the current context within an existing CacheInstance.
          *
-         * @param run - Optional function to clear cache for. If omitted, clears all cached instances.
+         * @template T - Function type
+         * @param run - Optional function to flush CacheInstance for. If omitted, flushes all CacheInstances.
          *
          * @example
          * ```typescript
-         * const cachedCalc = Cache.fn(calculateIndicator, { interval: "1h" });
+         * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
          *
-         * // Clear cache for specific function
-         * Cache.clear(calculateIndicator);
+         * // Flush CacheInstance for specific function
+         * Cache.flush(calculateIndicator);
          *
-         * // Clear all cached instances
-         * Cache.clear();
+         * // Flush all CacheInstances
+         * Cache.flush();
          * ```
          */
-        this.clear = (run) => {
-            backtest$1.loggerService.debug(CACHE_METHOD_NAME_CLEAR, {
+        this.flush = (run) => {
+            backtest$1.loggerService.info(CACHE_METHOD_NAME_FLUSH, {
                 run,
             });
             this._getInstance.clear(run);
         };
+        /**
+         * Clear cached value for current execution context of a specific function.
+         *
+         * Removes the cached entry for the current strategy/exchange/mode combination
+         * from the specified function's CacheInstance. The next call to the wrapped function
+         * will recompute the value for that context.
+         *
+         * This only clears the cache for the current execution context, not all contexts.
+         * Use `flush()` to remove the entire CacheInstance across all contexts.
+         *
+         * Requires active execution context (strategy, exchange, backtest mode) and method context.
+         *
+         * @template T - Function type
+         * @param run - Function whose cache should be cleared for current context
+         *
+         * @example
+         * ```typescript
+         * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
+         *
+         * // Within strategy execution context
+         * const result1 = cachedFn("BTCUSDT", 14); // Computed
+         * const result2 = cachedFn("BTCUSDT", 14); // Cached
+         *
+         * Cache.clear(calculateIndicator); // Clear cache for current context only
+         *
+         * const result3 = cachedFn("BTCUSDT", 14); // Recomputed for this context
+         * // Other contexts (different strategies/exchanges) remain cached
+         * ```
+         */
+        this.clear = (run) => {
+            backtest$1.loggerService.info(CACHE_METHOD_NAME_CLEAR, {
+                run,
+            });
+            this._getInstance.get(run).clear();
+        };
     }
 }
 /**

package/build/index.mjs

@@ -18424,7 +18424,8 @@ class ExchangeUtils {
  */
 const Exchange = new ExchangeUtils();
 
-const CACHE_METHOD_NAME_CLEAR = "CacheUtils.clear";
+const CACHE_METHOD_NAME_FLUSH = "CacheUtils.flush";
+const CACHE_METHOD_NAME_CLEAR = "CacheInstance.clear";
 const CACHE_METHOD_NAME_RUN = "CacheInstance.run";
 const CACHE_METHOD_NAME_FN = "CacheUtils.fn";
 const INTERVAL_MINUTES = {
@@ -18504,14 +18505,16 @@ class CacheInstance {
         this.run = (...args) => {
             backtest$1.loggerService.debug(CACHE_METHOD_NAME_RUN, { args });
             const step = INTERVAL_MINUTES[this.interval];
-            if (!step) {
-                throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
-            }
-            if (!MethodContextService.hasContext()) {
-                throw new Error("CacheInstance run requires method context");
-            }
-            if (!ExecutionContextService.hasContext()) {
-                throw new Error("CacheInstance run requires execution context");
+            {
+                if (!MethodContextService.hasContext()) {
+                    throw new Error("CacheInstance run requires method context");
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error("CacheInstance run requires execution context");
+                }
+                if (!step) {
+                    throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
+                }
             }
             const key = createKey(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
             const currentWhen = backtest$1.executionContextService.context.when;
@@ -18530,6 +18533,30 @@ class CacheInstance {
             this._cacheMap.set(key, newCache);
             return newCache;
         };
+        /**
+         * Clear cached value for current execution context.
+         *
+         * Removes the cached entry for the current strategy/exchange/mode combination
+         * from this instance's cache map. The next `run()` call will recompute the value.
+         *
+         * Requires active execution context (strategy, exchange, backtest mode) and method context
+         * to determine which cache entry to clear.
+         *
+         * @example
+         * ```typescript
+         * const instance = new CacheInstance(calculateIndicator, "1h");
+         * const result1 = instance.run("BTCUSDT", 14); // Computed
+         * const result2 = instance.run("BTCUSDT", 14); // Cached
+         *
+         * instance.clear(); // Clear cache for current context
+         *
+         * const result3 = instance.run("BTCUSDT", 14); // Recomputed
+         * ```
+         */
+        this.clear = () => {
+            const key = createKey(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
+            this._cacheMap.delete(key);
+        };
     }
 }
 /**
@@ -18578,45 +18605,85 @@ class CacheUtils {
          * ```
          */
         this.fn = (run, context) => {
-            backtest$1.loggerService.debug(CACHE_METHOD_NAME_FN, {
+            backtest$1.loggerService.info(CACHE_METHOD_NAME_FN, {
                 context,
             });
-            return (...args) => {
+            const wrappedFn = (...args) => {
                 const instance = this._getInstance(run, context.interval);
                 return instance.run(...args).value;
             };
+            return wrappedFn;
         };
         /**
-         * Clear cached instances for specific function or all cached functions.
+         * Flush (remove) cached CacheInstance for a specific function or all functions.
          *
-         * This method delegates to the memoized `_getInstance` function's clear method,
-         * which removes cached CacheInstance objects. When a CacheInstance is removed,
-         * all cached function results for that instance are also discarded.
+         * This method removes CacheInstance objects from the internal memoization cache.
+         * When a CacheInstance is flushed, all cached results across all contexts
+         * (all strategy/exchange/mode combinations) for that function are discarded.
          *
          * Use cases:
-         * - Clear cache for a specific function when its implementation changes
-         * - Free memory by removing unused cached instances
-         * - Reset all caches when switching contexts (e.g., between different backtests)
+         * - Remove specific function's CacheInstance when implementation changes
+         * - Free memory by removing unused CacheInstances
+         * - Reset all CacheInstances when switching between different test scenarios
+         *
+         * Note: This is different from `clear()` which only removes cached values
+         * for the current context within an existing CacheInstance.
          *
-         * @param run - Optional function to clear cache for. If omitted, clears all cached instances.
+         * @template T - Function type
+         * @param run - Optional function to flush CacheInstance for. If omitted, flushes all CacheInstances.
          *
          * @example
          * ```typescript
-         * const cachedCalc = Cache.fn(calculateIndicator, { interval: "1h" });
+         * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
          *
-         * // Clear cache for specific function
-         * Cache.clear(calculateIndicator);
+         * // Flush CacheInstance for specific function
+         * Cache.flush(calculateIndicator);
          *
-         * // Clear all cached instances
-         * Cache.clear();
+         * // Flush all CacheInstances
+         * Cache.flush();
          * ```
          */
-        this.clear = (run) => {
-            backtest$1.loggerService.debug(CACHE_METHOD_NAME_CLEAR, {
+        this.flush = (run) => {
+            backtest$1.loggerService.info(CACHE_METHOD_NAME_FLUSH, {
                 run,
             });
             this._getInstance.clear(run);
         };
+        /**
+         * Clear cached value for current execution context of a specific function.
+         *
+         * Removes the cached entry for the current strategy/exchange/mode combination
+         * from the specified function's CacheInstance. The next call to the wrapped function
+         * will recompute the value for that context.
+         *
+         * This only clears the cache for the current execution context, not all contexts.
+         * Use `flush()` to remove the entire CacheInstance across all contexts.
+         *
+         * Requires active execution context (strategy, exchange, backtest mode) and method context.
+         *
+         * @template T - Function type
+         * @param run - Function whose cache should be cleared for current context
+         *
+         * @example
+         * ```typescript
+         * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
+         *
+         * // Within strategy execution context
+         * const result1 = cachedFn("BTCUSDT", 14); // Computed
+         * const result2 = cachedFn("BTCUSDT", 14); // Cached
+         *
+         * Cache.clear(calculateIndicator); // Clear cache for current context only
+         *
+         * const result3 = cachedFn("BTCUSDT", 14); // Recomputed for this context
+         * // Other contexts (different strategies/exchanges) remain cached
+         * ```
+         */
+        this.clear = (run) => {
+            backtest$1.loggerService.info(CACHE_METHOD_NAME_CLEAR, {
+                run,
+            });
+            this._getInstance.get(run).clear();
+        };
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.5.36",
+  "version": "1.5.37",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -7865,33 +7865,67 @@ declare class CacheUtils {
      */
     fn: <T extends Function>(run: T, context: {
         interval: CandleInterval;
-    }) => Function;
+    }) => T;
     /**
-     * Clear cached instances for specific function or all cached functions.
+     * Flush (remove) cached CacheInstance for a specific function or all functions.
      *
-     * This method delegates to the memoized `_getInstance` function's clear method,
-     * which removes cached CacheInstance objects. When a CacheInstance is removed,
-     * all cached function results for that instance are also discarded.
+     * This method removes CacheInstance objects from the internal memoization cache.
+     * When a CacheInstance is flushed, all cached results across all contexts
+     * (all strategy/exchange/mode combinations) for that function are discarded.
      *
      * Use cases:
-     * - Clear cache for a specific function when its implementation changes
-     * - Free memory by removing unused cached instances
-     * - Reset all caches when switching contexts (e.g., between different backtests)
+     * - Remove specific function's CacheInstance when implementation changes
+     * - Free memory by removing unused CacheInstances
+     * - Reset all CacheInstances when switching between different test scenarios
      *
-     * @param run - Optional function to clear cache for. If omitted, clears all cached instances.
+     * Note: This is different from `clear()` which only removes cached values
+     * for the current context within an existing CacheInstance.
+     *
+     * @template T - Function type
+     * @param run - Optional function to flush CacheInstance for. If omitted, flushes all CacheInstances.
+     *
+     * @example
+     * ```typescript
+     * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
+     *
+     * // Flush CacheInstance for specific function
+     * Cache.flush(calculateIndicator);
+     *
+     * // Flush all CacheInstances
+     * Cache.flush();
+     * ```
+     */
+    flush: <T extends Function>(run?: T) => void;
+    /**
+     * Clear cached value for current execution context of a specific function.
+     *
+     * Removes the cached entry for the current strategy/exchange/mode combination
+     * from the specified function's CacheInstance. The next call to the wrapped function
+     * will recompute the value for that context.
+     *
+     * This only clears the cache for the current execution context, not all contexts.
+     * Use `flush()` to remove the entire CacheInstance across all contexts.
+     *
+     * Requires active execution context (strategy, exchange, backtest mode) and method context.
+     *
+     * @template T - Function type
+     * @param run - Function whose cache should be cleared for current context
      *
      * @example
      * ```typescript
-     * const cachedCalc = Cache.fn(calculateIndicator, { interval: "1h" });
+     * const cachedFn = Cache.fn(calculateIndicator, { interval: "1h" });
+     *
+     * // Within strategy execution context
+     * const result1 = cachedFn("BTCUSDT", 14); // Computed
+     * const result2 = cachedFn("BTCUSDT", 14); // Cached
      *
-     * // Clear cache for specific function
-     * Cache.clear(calculateIndicator);
+     * Cache.clear(calculateIndicator); // Clear cache for current context only
      *
-     * // Clear all cached instances
-     * Cache.clear();
+     * const result3 = cachedFn("BTCUSDT", 14); // Recomputed for this context
+     * // Other contexts (different strategies/exchanges) remain cached
      * ```
      */
-    clear: <T extends Function>(run?: T) => void;
+    clear: <T extends Function>(run: T) => void;
 }
 /**
  * Singleton instance of CacheUtils for convenient function caching.