@dxtmisha/wiki 0.39.7 → 0.56.0

package/src/media/functional/functional-basic/classes/CacheItem/CacheItem.en.mdx

@@ -1,94 +1,86 @@
 import {Meta} from '@storybook/addon-docs/blocks'
 
-<Meta title='@dxtmisha/en/functional-basic/Classes/CacheItem - Cache Entry Management'/>
+<Meta title='@dxtmisha/en/functional-basic/Classes/CacheItem - Advanced Cache Management'/>
 
 # CacheItem Class
 
+> **⚠️ Deprecated** — This class is obsolete and should not be used. / Этот класс устарел и не рекомендуется к использованию.
+
 The internal engine driving individual cache entries. While `Cache` and `CacheStatic` provide the public interfaces for retrieving cached data across your application, it is the `CacheItem` class that securely manages the lifecycle, storage, and invalidation rules for each specific value.
 
+> `CacheItem` is an **auxiliary class**, designed for internal management of individual cache entries. In most cases, it is recommended to interact with caching through the `Cache` or `CacheStatic` classes.
+
 ## Key Features
 
-- **Dependency Tracking** — maintains the comparison arrays used to determine if a cached value is still valid.
-- **Lazy Evaluation** — guarantees that the expensive callback function only runs when absolutely necessary.
-- **Historical Memory** — keeps a reference to the previously cached value (`getCacheOld`) even after recalculation happens.
-- **Async Execution** — natively handles both synchronous (`getCache`) and `Promise`-based asynchronous (`getCacheAsync`) data loading.
+- **Dependency Tracking** — maintains comparison arrays used to determine if a cached value remains valid.
+- **Lazy Evaluation** — ensures the expensive callback function only runs when dependencies have changed.
+- **Historical Memory** — keeps a reference to the previously cached value (`getCacheOld`) even after a recalculation occurs.
+- **Async Support** — natively handles both synchronous (`getCache`) and `Promise`-based asynchronous (`getCacheAsync`) data loading.
+- **Strict Invalidation** — uses deep comparison logic to trigger updates only when necessary.
 
+## Initialization
 
-You typically do not instantiate `CacheItem` directly in your application code. Instead, you use the `Cache` class, which manages `CacheItem` instances for you. However, understanding its API is helpful for advanced scenarios.
+As an auxiliary component, `CacheItem` is usually instantiated by higher-level managers. However, it can be created manually if custom, isolated caching logic is required.
 
-## Initialization
+### Generic Constraints
 
-To initialize the object, call the `CacheItem(callback)` constructor.
+The class supports the following generic to ensure strict typing of the cached value:
+- `T` — The type of the value being cached.
 
 **Parameters:**
-- `callback: () => T` — a function that will generate data for the cache.
+- `callback: () => T` — a function that will generate or fetch data for the cache.
 
 ```typescript
-import { CacheItem } from '@dxtmisha/functional'
+import { CacheItem } from '@dxtmisha/functional-basic'
 
 // 1. Initialization with a data retrieval function
 const userCache = new CacheItem(() => fetchUserData())
+
+// 2. Using generics for strict typing
+const numberCache = new CacheItem<number>(() => Math.random())
 ```
 
-## Cache Retrieval
+## Methods
 
-### `getCache`
+### Cache Access
 
-Use `getCache` to obtain the value. The provided comparison array determines if recalculation is needed.
+- `getCache(comparison?: any[]): T` — Retrieves the value from the cache. If the comparison dependencies have changed, it triggers a recalculation.
+- `getCacheAsync(comparison?: any[]): Promise<T>` — Asynchronous version of `getCache`. Returns a Promise that resolves to the cached or newly fetched data.
 
-**Parameters:**
-- `comparison?: any[]` — array of dependencies. If they change, the callback is re-evaluated.
+### History
 
-**Returns:** `T` — the cached or freshly stringified value.
+- `getCacheOld(): T | undefined` — Returns the value that was stored in the cache immediately prior to the last update.
 
+## Examples
+
+### Dependency-Based Invalidation
 ```javascript
 let count = 0
 const counterCache = new CacheItem(() => ++count)
 
-// Evaluates and caches 1
-counterCache.getCache([1])
-
-// Returns cached 1 (dependencies match)
-counterCache.getCache([1])
-
-// Dependencies changed to [2], evaluates and caches 2
-counterCache.getCache([2])
-```
-
-### `getCacheAsync`
+// First call: evaluates and caches 1
+counterCache.getCache([10]) // returns 1
 
-Functions exactly like `getCache`, but handles `Promise` returns.
+// Second call: dependencies match [10], returns cached 1
+counterCache.getCache([10]) // returns 1
 
-**Parameters:**
-- `comparison?: any[]` — array of dependencies.
+// Third call: dependencies changed to [20], evaluates and caches 2
+counterCache.getCache([20]) // returns 2
 
-**Returns:** `Promise<T>` — the cached or newly fetched promise.
+// Check history:
+console.log(counterCache.getCacheOld()) // returns 1
+```
 
+### Async API Caching
 ```javascript
-const apiCache = new CacheItem(async () => await fetch('/data').then(res => res.json()))
+const apiCache = new CacheItem(async () => {
+  const response = await fetch('/api/data')
+  return response.json()
+})
 
-// Fetches from the network
+// Fetches from the network for the first 'v1' request
 const data1 = await apiCache.getCacheAsync(['v1'])
 
-// Returns from cache instantly
+// Returns from cache instantly for subsequent 'v1' requests
 const data2 = await apiCache.getCacheAsync(['v1'])
 ```
-
-## Historical Data
-
-### `getCacheOld`
-
-If a cache invalidation occurs and new data is fetched, you can retrieve the immediate prior value using `getCacheOld()`.
-
-**Returns:** `T | undefined` — the previously cached data, if available.
-
-```javascript
-counterCache.getCache([1]) // Returns 1
-counterCache.getCache([2]) // Returns 2
-
-console.log(counterCache.getCacheOld()) // Returns 1
-```
-
-## Internal Overview
-
-`CacheItem` relies on the internal `isUpdate` method to strictly compare the incoming `comparison` array against the previous one. If they differ in length or strict equality (`===`) of their elements, the cache is flagged as stale and the internal `value` is regenerated.

package/src/media/functional/functional-basic/classes/CacheItem/CacheItem.ru.mdx

@@ -1,94 +1,86 @@
 import {Meta} from '@storybook/addon-docs/blocks'
 
-<Meta title='@dxtmisha/ru/functional-basic/Classes/CacheItem - Управление записью кэша'/>
+<Meta title='@dxtmisha/ru/functional-basic/Classes/CacheItem - Продвинутое Управление Кэшем'/>
 
 # Класс CacheItem
 
-Внутренний движок, управляющий отдельными записями кэша. В то время как `Cache` и `CacheStatic` предоставляют публичные интерфейсы для извлечения кэшированных данных в вашем приложении, именно класс `CacheItem` надежно управляет жизненным циклом, хранением и правилами инвалидации конкретного значения.
+> **⚠️ Устарел** — Этот класс устарел и не рекомендуется к использованию.
 
-## Ключевые особенности
+Внутренний механизм, управляющий отдельными записями кэша. В то время как `Cache` и `CacheStatic` предоставляют публичные интерфейсы для работы с глобальным кэшем приложения, именно класс `CacheItem` отвечает за жизненный цикл, хранение и правила инвалидации каждого конкретного значения.
 
-- **Отслеживание зависимостей** — поддерживает массивы сравнения, используемые для определения того, действительно ли кэшированное значение.
-- **Ленивые вычисления** — гарантирует, что ресурсоемкая функция обратного вызова (callback) запускается только тогда, когда это абсолютно необходимо.
-- **Историческая память** — сохраняет ссылку на ранее кэшированное значение (`getCacheOld`) даже после пересчета.
-- **Асинхронное выполнение** — нативно обрабатывает как синхронную (`getCache`), так и асинхронную загрузку данных на основе `Promise` (`getCacheAsync`).
+> `CacheItem` является **вспомогательным классом**, предназначенным для внутреннего управления отдельными записями кэша. В большинстве случаев рекомендуется взаимодействовать с кэшированием через классы `Cache` или `CacheStatic`.
 
+## Ключевые особенности
 
-Обычно вы не создаете экземпляры `CacheItem` напрямую в коде приложения. Вместо этого вы используете класс `Cache`, который сам управляет экземплярами `CacheItem`. Однако понимание его API полезно для сложных сценариев.
+- **Отслеживание зависимостей** — поддерживает массивы сравнения для определения актуальности закэшированного значения.
+- **Ленивые вычисления** — гарантирует, что ресурсоемкая функция (callback) запускается только при изменении зависимостей.
+- **Историческая память** — сохраняет ссылку на предыдущее значение (`getCacheOld`) даже после обновления кэша.
+- **Асинхронная поддержка** — нативная работа как с синхронными (`getCache`), так и с асинхронными (`getCacheAsync`) данными.
+- **Строгая инвалидация** — использует логику глубокого сравнения для минимизации лишних вычислений.
 
 ## Инициализация
 
-Для инициализации объекта вызовите конструктор `CacheItem(callback)`.
+Как вспомогательный компонент, `CacheItem` обычно создается менеджерами более высокого уровня. Тем не менее, его можно инициализировать вручную, если требуется кастомная, изолированная логика кэширования.
+
+### Ограничения дженериков (Generic Constraints)
+
+Для обеспечения строгой типизации закэшированного значения класс поддерживает следующий дженерик:
+- `T` — Тип данных, хранящихся в кэше.
 
 **Параметры:**
-- `callback: () => T` — функция, которая будет генерировать данные для кэша.
+- `callback: () => T` — функция, которая генерирует или загружает данные для кэша.
 
 ```typescript
-import { CacheItem } from '@dxtmisha/functional'
+import { CacheItem } from '@dxtmisha/functional-basic'
 
 // 1. Инициализация с функцией получения данных
 const userCache = new CacheItem(() => fetchUserData())
+
+// 2. Использование дженериков для строгой типизации
+const numberCache = new CacheItem<number>(() => Math.random())
 ```
 
-## Извлечение кэша
+## Методы
 
-### `getCache`
+### Доступ к кэшу
 
-Используйте `getCache` для получения значения. Предоставленный массив сравнения определяет необходимость пересчета.
+- `getCache(comparison?: any[]): T` — Извлекает значение из кэша. Если массив зависимостей `comparison` изменился, запускает пересчет.
+- `getCacheAsync(comparison?: any[]): Promise<T>` — Асинхронная версия `getCache`. Возвращает Promise, который разрешается в закэшированные или новые данные.
 
-**Параметры:**
-- `comparison?: any[]` — массив зависимостей. Если они меняются, колбэк вычисляется заново.
+### История
 
-**Возвращает:** `T` — закэшированное или вычисленное значение.
+- `getCacheOld(): T | undefined` — Возвращает значение, которое хранилось в кэше непосредственно до последнего обновления.
 
+## Примеры
+
+### Инвалидация на основе зависимостей
 ```javascript
 let count = 0
 const counterCache = new CacheItem(() => ++count)
 
-// Вычисляет и кэширует 1
-counterCache.getCache([1])
-
-// Возвращает закэшированную 1 (зависимости совпадают)
-counterCache.getCache([1])
-
-// Зависимости изменились на [2], вычисляет и кэширует 2
-counterCache.getCache([2])
-```
-
-### `getCacheAsync`
+// Первый вызов: вычисляет и кэширует 1
+counterCache.getCache([10]) // возвращает 1
 
-Работает точно так же, как `getCache`, но обрабатывает возврат `Promise`.
+// Второй вызов: зависимости [10] не изменились, возвращает закэшированную 1
+counterCache.getCache([10]) // возвращает 1
 
-**Параметры:**
-- `comparison?: any[]` — опциональный массив зависимостей.
+// Третий вызов: зависимости изменились на [20], вычисляет и кэширует 2
+counterCache.getCache([20]) // возвращает 2
 
-**Возвращает:** `Promise<T>` — асинхронное значение из кэша.
+// Проверка истории:
+console.log(counterCache.getCacheOld()) // возвращает 1
+```
 
+### Кэширование данных API
 ```javascript
-const apiCache = new CacheItem(async () => await fetch('/data').then(res => res.json()))
+const apiCache = new CacheItem(async () => {
+  const response = await fetch('/api/data')
+  return response.json()
+})
 
-// Загружает из сети
+// Загружает данные из сети при первом запросе с ключом 'v1'
 const data1 = await apiCache.getCacheAsync(['v1'])
 
-// Возвращает из кэша мгновенно
+// Возвращает данные мгновенно из кэша для последующих запросов 'v1'
 const data2 = await apiCache.getCacheAsync(['v1'])
 ```
-
-## Исторические данные
-
-### `getCacheOld`
-
-Если происходит очистка кэша и загружаются новые данные, вы можете извлечь непосредственное предшествующее значение с помощью `getCacheOld()`.
-
-**Возвращает:** `T | undefined` — предыдущие закэшированные данные.
-
-```javascript
-counterCache.getCache([1]) // Возвращает 1
-counterCache.getCache([2]) // Возвращает 2
-
-console.log(counterCache.getCacheOld()) // Возвращает 1
-```
-
-## Внутреннее устройство
-
-`CacheItem` опирается на внутренний метод `isUpdate` для строгого сравнения входящего массива `comparison` с предыдущим. Если они отличаются по длине или строгому равенству (`===`) своих элементов, кэш помечается как устаревший, и внутреннее свойство `value` регенерируется.

package/src/media/functional/functional-basic/classes/CacheItem/CacheItem.vi.mdx

@@ -1,94 +1,86 @@
 import {Meta} from '@storybook/addon-docs/blocks'
 
-<Meta title='@dxtmisha/vi/functional-basic/Classes/CacheItem - Quản lý mục lưu trữ bộ nhớ đệm'/>
+<Meta title='@dxtmisha/vi/functional-basic/Classes/CacheItem - Quản lý Bộ nhớ đệm Nâng cao'/>
 
 # Lớp CacheItem
 
-Hệ thống cốt lõi (engine) quản lý độc lập từng mục lưu vào bộ nhớ cache. Trong khi `Cache` và `CacheStatic` đóng vai trò là giao diện chung giúp lấy dữ liệu đang hoạt động trên hệ thống ứng dụng, thì `CacheItem` tạo những luồng bảo mật nghiêm ngặt kiểm soát vòng đời trạng thái (lifecycle), nơi lưu giữ biến nhớ, cũng như tính hợp lệ kết thúc vòng tuần hoàn cho từng giá trị được cấu hình cụ thể nhất.
+> **⚠️ Đã lỗi thời** — Lớp này đã lỗi thời và không nên được sử dụng.
 
-## Các tính năng chính
+Hệ thống cốt lõi quản lý từng mục lưu trữ bộ nhớ đệm (cache) riêng biệt. Trong khi `Cache` và `CacheStatic` cung cấp các giao diện công khai để truy xuất dữ liệu cache trong toàn bộ ứng dụng, thì lớp `CacheItem` đảm nhận việc quản lý an toàn vòng đời, lưu trữ và các quy tắc vô hiệu hóa (invalidation) cho từng giá trị cụ thể.
 
-- **Trình theo dõi bộ phụ thuộc (Dependency Tracking)** — duy trì mảng so sánh dùng làm gốc để tính toán nếu biến dữ liệu lưu trữ bị phát hiện tính vô hiệu/biến đổi sai lệch so với lần cuối lưu.
-- **Tính toán tuần tự (Lazy Evaluation)** — thực hiện nguyên lý tối giản tài nguyên: chỉ chạy lại quy trình tìm nạp từ đầu ở đoạn function nếu mảng lưu trữ đang bị lỗi thời hỏng cấu trúc.
-- **Lưu trữ ghi nhớ bộ đệm cũ (Historical Memory)** — vẫn giữ dữ liệu thuộc vùng cache cũ (`getCacheOld`) kể cả khi chức năng ghi đè/tỉnh toán lại đã hoàn tất.
-- **Thực thi Async** — hỗ trợ hoàn hảo phương pháp đồng bộ (`getCache`) và bất đồng bộ chạy kèm logic `Promise` (`getCacheAsync`) ở tiến trình nạp mảng dữ liệu.
+> `CacheItem` là một **lớp phụ trợ**, được thiết kế để quản lý nội bộ các mục lưu trữ bộ nhớ đệm riêng lẻ. Trong hầu hết các trường hợp, bạn nên tương tác với bộ nhớ đệm thông qua các lớp `Cache` hoặc `CacheStatic`.
 
+## Các tính năng chính
 
-Bạn thường không trực tiếp gọi/khởi tạo Class `CacheItem` trong mã ứng dụng của mình. Thay vào đó, bạn sử dụng `Cache` và class đó tự động bao đóng `CacheItem` ở định dạng nội bộ cho bạn. Dù vậy, việc hiểu rõ các hàm API từ gốc cũng hữu ích trong việc xây dựng kiến trúc nền nâng cao.
+- **Theo dõi phụ thuộc** — duy trì các mảng so sánh để xác định xem giá trị được lưu trong bộ nhớ đệm có còn hiệu lực hay không.
+- **Tính toán lười (Lazy Evaluation)** — đảm bảo rằng hàm callback (vốn có thể tốn kém tài nguyên) chỉ chạy khi các thành phần phụ thuộc thực sự thay đổi.
+- **Bộ nhớ lịch sử** — giữ lại tham chiếu đến giá trị đã lưu trước đó (`getCacheOld`) ngay cả khi quá trình tính toán lại đã diễn ra.
+- **Hỗ trợ Async** — xử lý tự nhiên cả việc nạp dữ liệu đồng bộ (`getCache`) và bất đồng bộ dựa trên `Promise` (`getCacheAsync`).
+- **Vô hiệu hóa nghiêm ngặt** — sử dụng logic so sánh sâu để chỉ kích hoạt cập nhật khi thực sự cần thiết.
 
 ## Khởi tạo
 
-Để khởi tạo đối tượng, hãy gọi hàm khởi tạo `CacheItem(callback)`.
+Là một thành phần phụ trợ, `CacheItem` thường được khởi tạo bởi các trình quản lý cấp cao hơn. Tuy nhiên, nó có thể được tạo thủ công nếu yêu cầu logic lưu trữ bộ nhớ đệm riêng biệt và tùy chỉnh.
+
+### Ràng buộc Generic (Generic Constraints)
+
+Lớp hỗ trợ generic sau để đảm bảo kiểm soát kiểu dữ liệu nghiêm ngặt cho giá trị được lưu:
+- `T` — Kiểu dữ liệu của giá trị được lưu trong bộ nhớ đệm.
 
 **Tham số:**
-- `callback: () => T` — hàm sẽ tạo dữ liệu cho bộ nhớ đệm.
+- `callback: () => T` — một hàm sẽ tạo hoặc lấy dữ liệu cho bộ nhớ đệm.
 
 ```typescript
-import { CacheItem } from '@dxtmisha/functional'
+import { CacheItem } from '@dxtmisha/functional-basic'
 
-// 1. Khởi tạo với hàm lấy dữ liệu
+// 1. Khởi tạo với một hàm truy xuất dữ liệu
 const userCache = new CacheItem(() => fetchUserData())
+
+// 2. Sử dụng generic để kiểm soát kiểu dữ liệu nghiêm ngặt
+const numberCache = new CacheItem<number>(() => Math.random())
 ```
 
-## Lấy dữ liệu bộ nhớ đệm
+## Các phương thức
 
-### `getCache`
+### Truy cập Bộ nhớ đệm
 
-Dùng `getCache` để móc nối lấy lại biến lưu trữ. Thiết lập cấu hình biến mảng đi kèm đóng vai trò so sánh mức độ trùng khớp cho tiến trình phân giải.
+- `getCache(comparison?: any[]): T` — Lấy giá trị từ bộ nhớ đệm. Nếu các thành phần phụ thuộc trong mảng `comparison` thay đổi, nó sẽ kích hoạt tính toán lại.
+- `getCacheAsync(comparison?: any[]): Promise<T>` — Phiên bản bất đồng bộ của `getCache`. Trả về một Promise giải quyết thành dữ liệu đã lưu hoặc dữ liệu mới được lấy về.
 
-**Tham số:**
-- `comparison?: any[]` — danh sách các đối tượng thiết lập kèm. Nếu thông tin bị sai với lúc lưu lại thì callback tự động phân tách cấu trúc tính toán lần nữa.
+### Lịch sử
 
-**Trả về:** `T` — dữ liệu nguyên mẫu.
+- `getCacheOld(): T | undefined` — Trả về giá trị đã được lưu trong bộ nhớ đệm ngay trước lần cập nhật cuối cùng.
 
+## Ví dụ
+
+### Vô hiệu hóa dựa trên phụ thuộc
 ```javascript
 let count = 0
 const counterCache = new CacheItem(() => ++count)
 
-// Hàm đánh giá gọi: 1
-counterCache.getCache([1])
-
-// Tìm ngay cache nhận dạng lưu: 1
-counterCache.getCache([1])
-
-// Tham số gắn kết biến đổi qua [2], xoá cache khởi động và lưu kết quả: 2
-counterCache.getCache([2])
-```
-
-### `getCacheAsync`
+// Gọi lần đầu: tính toán và lưu cache giá trị 1
+counterCache.getCache([10]) // trả về 1
 
-Mọi thông số giống với cách thiết lập và làm việc của `getCache`, nhưng hệ thống tiếp nhận biến `Promise` trả ra khi cần.
+// Gọi lần hai: các thành phần phụ thuộc khớp với [10], trả về giá trị 1 đã lưu
+counterCache.getCache([10]) // trả về 1
 
-**Tham số:**
-- `comparison?: any[]` — mảng phụ thuộc.
+// Gọi lần ba: các thành phần phụ thuộc thay đổi thành [20], tính toán và lưu cache giá trị 2
+counterCache.getCache([20]) // trả về 2
 
-**Trả về:** `Promise<T>` — dữ liệu `Promise` được tạo kết nối mạng.
+// Kiểm tra lịch sử:
+console.log(counterCache.getCacheOld()) // trả về 1
+```
 
+### Cấu hình Cache cho API Async
 ```javascript
-const apiCache = new CacheItem(async () => await fetch('/data').then(res => res.json()))
+const apiCache = new CacheItem(async () => {
+  const response = await fetch('/api/data')
+  return response.json()
+})
 
-// Chạy mạng network để tải API thông tin
+// Lấy dữ liệu từ mạng cho yêu cầu 'v1' đầu tiên
 const data1 = await apiCache.getCacheAsync(['v1'])
 
-// Vượt lớp mạng trỏ thẳng đến bộ đệm lưu trữ
+// Trả về từ bộ nhớ đệm ngay lập tức cho các yêu cầu 'v1' tiếp theo
 const data2 = await apiCache.getCacheAsync(['v1'])
 ```
-
-## Dữ liệu lịch sử
-
-### `getCacheOld`
-
-Hàm phụ lấy lại biến thuộc nhóm ghi đè trước lần cuối tái tạo cache data, thông qua lệnh gọi `getCacheOld()`.
-
-**Trả về:** `T | undefined` — biến định danh cũ nhất.
-
-```javascript
-counterCache.getCache([1]) // Trả 1
-counterCache.getCache([2]) // Trả 2
-
-console.log(counterCache.getCacheOld()) // Trả 1
-```
-
-## Tổng quan nội bộ
-
-`CacheItem` hoạt động chặt qua module `isUpdate` tiến hành phân giải và đánh dấu (`===`) xem giá trị từ array đầu vào của thuộc tính biến tham chiếu `comparison` với độ tin cậy được thiết lập từ mảng cũ đã giống về độ dài cấu trúc hoặc số chiều trong node hay không. Chỉ cần một giá trị khác với biến ban đầu thì `CacheItem` đánh dấu mảng thành cấu trúc chết (stale/hỏng) để tạo tiến trình đẩy `value` tính lại toàn bộ.

package/src/media/functional/functional-basic/classes/CacheStatic/CacheStatic.en.mdx

@@ -4,6 +4,8 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 # CacheStatic Class
 
+> **⚠️ Deprecated** — This class is obsolete and should not be used. / Этот класс устарел и не рекомендуется к использованию.
+
 A wrapper class providing a globally accessible, static cache instance. It allows you to perform fast caching operations anywhere during code execution without needing to instantiate or pass around a dedicated `Cache` object.
 
 ## Key Features
@@ -47,7 +49,17 @@ function calculateHeavyData(id) {
 const res1 = calculateHeavyData(5) 
 
 // File B.js
-// Same function, same id. It hits the global cache.
 // Will NOT log 'Calculating...', instantly returns 500
 const res2 = calculateHeavyData(5) 
 ```
+
+### `getAsync`
+
+Asynchronous version of the `get()` method. Useful when the callback function returns a `Promise`.
+
+**Parameters:**
+- `name: string` — a unique identifier for the specific global cache entry.
+- `callback: () => Promise<T> | T` — the asynchronous function that computes the value.
+- `comparison?: any[]` — optional array of dependencies. Passing a new array (where values or length differ) invalidates the cache and forces a recalculation.
+
+**Returns:** `Promise<T>` — a promise that resolves to the cached or computed value.

package/src/media/functional/functional-basic/classes/CacheStatic/CacheStatic.ru.mdx

@@ -4,6 +4,8 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 # Класс CacheStatic
 
+> **⚠️ Устарел** — Этот класс устарел и не рекомендуется к использованию.
+
 Класс-обертка, предоставляющий глобально доступный статический экземпляр кэша. Он позволяет выполнять операции быстрого кэширования в любом месте во время выполнения кода без необходимости создавать экземпляр или передавать объект `Cache`.
 
 ## Ключевые особенности
@@ -47,7 +49,17 @@ function calculateHeavyData(id) {
 const res1 = calculateHeavyData(5) 
 
 // Файл B.js
-// Та же функция, тот же id. Попадает в глобальный кэш.
 // НЕ будет выводить 'Вычисляем...', мгновенно вернет 500
 const res2 = calculateHeavyData(5) 
 ```
+
+### `getAsync`
+
+Асинхронная версия метода `get()`. Полезна, когда функция обратного вызова возвращает `Promise`.
+
+**Параметры:**
+- `name: string` — уникальный идентификатор для вашей записи в глобальном кэше.
+- `callback: () => Promise<T> | T` — асинхронная функция, которая вычисляет значение.
+- `comparison?: any[]` — опциональный массив зависимостей. Передача нового массива (где значения или длина отличаются) очищает кэш и вызывает пересчет.
+
+**Возвращает:** `Promise<T>` — промис, который разрешается в кэшированное или вычисленное значение.

package/src/media/functional/functional-basic/classes/CacheStatic/CacheStatic.vi.mdx

@@ -4,6 +4,8 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 # Lớp CacheStatic
 
+> **⚠️ Đã lỗi thời** — Lớp này đã lỗi thời và không nên được sử dụng.
+
 Một lớp định dạng lớp bọc ngoài (wrapper class) đóng vai trò xây dựng lớp giao tiếp toàn cục sử dụng bộ nhớ cache tĩnh (static cache instance). Với `CacheStatic`, cơ chế hoạt động giúp bộ nhớ có tính linh hoạt xuyên suốt đoạn code ở mọi nơi trong phân lớp code được thực thi, thay thế và loại bỏ hoàn toàn quá trình tạo đối tượng object `Cache` chuyên biệt như cấu trúc gốc.
 
 ## Các tính năng chính
@@ -51,3 +53,14 @@ const res1 = calculateHeavyData(5)
 // Không thực thi lại callback 'Calculating...', kết xuất liền giá trị 500.
 const res2 = calculateHeavyData(5) 
 ```
+
+### `getAsync`
+
+Phiên bản bất đồng bộ của phương thức `get()`. Hữu ích khi hàm callback trả về một `Promise`.
+
+**Tham số:**
+- `name: string` — định danh duy nhất cho mục nhập cache toàn cục cụ thể.
+- `callback: () => Promise<T> | T` — hàm bất đồng bộ thực hiện tính toán giá trị.
+- `comparison?: any[]` — mảng phụ thuộc tùy chọn. Việc truyền một mảng mới (nơi các giá trị hoặc độ dài khác nhau) sẽ vô hiệu hóa bộ nhớ đệm và buộc tính toán lại.
+
+**Trả về:** `Promise<T>` — một promise trả về giá trị đã lưu trong bộ nhớ đệm hoặc giá trị vừa được tính toán.