@dxtmisha/wiki 0.25.1 → 0.39.2

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

@@ -0,0 +1,84 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Classes/Cache - Bộ nhớ đệm cơ bản'/>
+
+# Lớp Cache
+
+Một cơ chế caching dựa trên lưu trữ bộ nhớ nhẹ. Chức năng này cung cấp cách làm hiệu quả để thực thi các tác vụ hay hàm tìm nạp dữ liệu tiêu tốn năng lượng hoạt động và thời gian chỉ khi thực sự cần thiết, phụ thuộc vào "mảng so sánh" (comparison array) để tiến hành invalidation cache cũng như việc tính toán ghi đè lại.
+
+## Các tính năng chính
+
+- **Thực thi trên nhu cầu (On-Demand Evaluation)** — các function chỉ chạy khi không tìm thấy bộ nhớ cache mong muốn do rỗng hoặc vô hiệu (invalidation).
+- **Vô hiệu qua phép so sánh mảng** — Cache module sẽ tự vô hiệu và tiến hành nạp lại hoàn toàn dữ liệu vào array nếu giá trị phần tử thuộc mảng nhận chỉ định không giống với lúc lưu. Chức năng khá giống dependency arrays ở `useEffect` hoặc `useMemo` của React.
+- **Hỗ trợ chạy Async** — quá trình đồng bộ hoạt động dựa vào cách kết nối của phương pháp `Promise`.
+
+## Khởi tạo
+
+Để khởi tạo đối tượng, hãy gọi hàm khởi tạo `Cache()`.
+
+```typescript
+import { Cache } from '@dxtmisha/functional'
+
+// 1. Khởi tạo bộ lưu trữ
+const cache = new Cache()
+
+// 2. Lấy hoặc tính toán giá trị
+const user = cache.get('user', () => 'Admin', [1])
+```
+
+## Lấy dữ liệu
+
+### `get`
+
+Sử dụng phương thức `get()` kết nối trực tiếp với giá trị cache được gắn cố định hoặc thay mới ngay nếu dữ liệu hiện thuộc trạng thái lưu đã ngừng hoạt động/quá hạn/bị lỗi (stale block).
+
+**Tham số:**
+- `name: string` — mã định danh để nạp bộ nhớ đệm cache.
+- `callback: () => T` — đoạn code (function) định nghĩa cho mảng trả về (value computation).
+- `comparison?: any[]` — thiết lập phụ array lưu trữ độ gắn kết. Nếu nhận thấy biến bên mảng khác hoàn toàn sau bước thực hiện lấy cache gần nhất thì class tự reset tính hợp lệ và cho hàm `callback` rà lại quá trình khởi tạo một lần nữa.
+
+**Trả về:** `T` — dữ liệu cache.
+
+```javascript
+let counter = 0
+
+// Tính và thiết lập cache nhận: "User 1"
+const user1 = cache.get('user', () => `User ${++counter}`, [1])
+
+// KHÔNG CHẠY CODE, chỉ kéo cache được ghi từ "User 1"
+const unchanged = cache.get('user', () => `User ${++counter}`, [1])
+
+// Mảng gắn kết thay đổi từ [1] sang [2]
+// Xóa cache và nạp vào: "User 2"
+const changed = cache.get('user', () => `User ${++counter}`, [2])
+```
+
+### `getAsync`
+
+Tương tự như `get()` nhưng cấu hình định hướng đến Async calls.
+
+**Tham số:**
+- `name: string` — mã định danh bộ nhớ.
+- `callback: () => Promise<T>` — hàm bất đồng bộ trả về kết quả.
+- `comparison?: any[]` — danh sách các đối tượng kèm theo.
+
+**Trả về:** `Promise<T>` — dữ liệu `Promise` được tạo mới hoặc lấy từ cache.
+
+```javascript
+async function fetchUser(id) {
+  return cache.getAsync('user_api', async () => {
+    const res = await fetch(`/api/users/${id}`)
+    return res.json()
+  }, [id])
+}
+
+// Bắn thông tin vào luồng network ban đầu
+const u1 = await fetchUser(5)
+
+// Chạy lại hàm cũ gọi trực tiếp từ cache đã tạo
+const u1Cached = await fetchUser(5)
+
+// Tham số gắn kết biến đổi `id` đã chạy (5 !== 6), bắn luồng lên node mới
+const u2 = await fetchUser(6)
+```
+

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

@@ -0,0 +1,94 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Classes/CacheItem - Cache Entry Management'/>
+
+# CacheItem Class
+
+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.
+
+## 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.
+
+
+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.
+
+## Initialization
+
+To initialize the object, call the `CacheItem(callback)` constructor.
+
+**Parameters:**
+- `callback: () => T` — a function that will generate data for the cache.
+
+```typescript
+import { CacheItem } from '@dxtmisha/functional'
+
+// 1. Initialization with a data retrieval function
+const userCache = new CacheItem(() => fetchUserData())
+```
+
+## Cache Retrieval
+
+### `getCache`
+
+Use `getCache` to obtain the value. The provided comparison array determines if recalculation is needed.
+
+**Parameters:**
+- `comparison?: any[]` — array of dependencies. If they change, the callback is re-evaluated.
+
+**Returns:** `T` — the cached or freshly stringified value.
+
+```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`
+
+Functions exactly like `getCache`, but handles `Promise` returns.
+
+**Parameters:**
+- `comparison?: any[]` — array of dependencies.
+
+**Returns:** `Promise<T>` — the cached or newly fetched promise.
+
+```javascript
+const apiCache = new CacheItem(async () => await fetch('/data').then(res => res.json()))
+
+// Fetches from the network
+const data1 = await apiCache.getCacheAsync(['v1'])
+
+// Returns from cache instantly
+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

@@ -0,0 +1,94 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Classes/CacheItem - Управление записью кэша'/>
+
+# Класс CacheItem
+
+Внутренний движок, управляющий отдельными записями кэша. В то время как `Cache` и `CacheStatic` предоставляют публичные интерфейсы для извлечения кэшированных данных в вашем приложении, именно класс `CacheItem` надежно управляет жизненным циклом, хранением и правилами инвалидации конкретного значения.
+
+## Ключевые особенности
+
+- **Отслеживание зависимостей** — поддерживает массивы сравнения, используемые для определения того, действительно ли кэшированное значение.
+- **Ленивые вычисления** — гарантирует, что ресурсоемкая функция обратного вызова (callback) запускается только тогда, когда это абсолютно необходимо.
+- **Историческая память** — сохраняет ссылку на ранее кэшированное значение (`getCacheOld`) даже после пересчета.
+- **Асинхронное выполнение** — нативно обрабатывает как синхронную (`getCache`), так и асинхронную загрузку данных на основе `Promise` (`getCacheAsync`).
+
+
+Обычно вы не создаете экземпляры `CacheItem` напрямую в коде приложения. Вместо этого вы используете класс `Cache`, который сам управляет экземплярами `CacheItem`. Однако понимание его API полезно для сложных сценариев.
+
+## Инициализация
+
+Для инициализации объекта вызовите конструктор `CacheItem(callback)`.
+
+**Параметры:**
+- `callback: () => T` — функция, которая будет генерировать данные для кэша.
+
+```typescript
+import { CacheItem } from '@dxtmisha/functional'
+
+// 1. Инициализация с функцией получения данных
+const userCache = new CacheItem(() => fetchUserData())
+```
+
+## Извлечение кэша
+
+### `getCache`
+
+Используйте `getCache` для получения значения. Предоставленный массив сравнения определяет необходимость пересчета.
+
+**Параметры:**
+- `comparison?: any[]` — массив зависимостей. Если они меняются, колбэк вычисляется заново.
+
+**Возвращает:** `T` — закэшированное или вычисленное значение.
+
+```javascript
+let count = 0
+const counterCache = new CacheItem(() => ++count)
+
+// Вычисляет и кэширует 1
+counterCache.getCache([1])
+
+// Возвращает закэшированную 1 (зависимости совпадают)
+counterCache.getCache([1])
+
+// Зависимости изменились на [2], вычисляет и кэширует 2
+counterCache.getCache([2])
+```
+
+### `getCacheAsync`
+
+Работает точно так же, как `getCache`, но обрабатывает возврат `Promise`.
+
+**Параметры:**
+- `comparison?: any[]` — опциональный массив зависимостей.
+
+**Возвращает:** `Promise<T>` — асинхронное значение из кэша.
+
+```javascript
+const apiCache = new CacheItem(async () => await fetch('/data').then(res => res.json()))
+
+// Загружает из сети
+const data1 = await apiCache.getCacheAsync(['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

@@ -0,0 +1,94 @@
+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'/>
+
+# 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.
+
+## Các tính năng chính
+
+- **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.
+
+
+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.
+
+## Khởi tạo
+
+Để khởi tạo đối tượng, hãy gọi hàm khởi tạo `CacheItem(callback)`.
+
+**Tham số:**
+- `callback: () => T` — hàm sẽ tạo dữ liệu cho bộ nhớ đệm.
+
+```typescript
+import { CacheItem } from '@dxtmisha/functional'
+
+// 1. Khởi tạo với hàm lấy dữ liệu
+const userCache = new CacheItem(() => fetchUserData())
+```
+
+## Lấy dữ liệu bộ nhớ đệm
+
+### `getCache`
+
+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.
+
+**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.
+
+**Trả về:** `T` — dữ liệu nguyên mẫu.
+
+```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`
+
+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.
+
+**Tham số:**
+- `comparison?: any[]` — mảng phụ thuộc.
+
+**Trả về:** `Promise<T>` — dữ liệu `Promise` được tạo kết nối mạng.
+
+```javascript
+const apiCache = new CacheItem(async () => await fetch('/data').then(res => res.json()))
+
+// Chạy mạng network để tải API thông tin
+const data1 = await apiCache.getCacheAsync(['v1'])
+
+// Vượt lớp mạng trỏ thẳng đến bộ đệm lưu trữ
+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

@@ -0,0 +1,53 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Classes/CacheStatic - Fast Global Cache'/>
+
+# CacheStatic Class
+
+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
+
+- **Global Accessibility** — works as a singleton pattern using static methods, meaning the same cache pool is accessible throughout the application context.
+- **Underlying Mechanism** — internally delegates all calls to a standard `Cache` instance, giving you the same dependency tracking and lazy evaluation benefits.
+- **Convenience** — perfect for simple, shared data caching requirements across multiple unlinked components.
+
+
+Since all methods are `static`, you never call `new CacheStatic()`. You interact with the class directly.
+
+## Global Caching
+
+### `get`
+
+Use the static `get()` method to retrieve a cached value or calculate it if missing.
+
+**Parameters:**
+- `name: string` — a unique identifier for the specific global cache entry.
+- `callback: () => T` — the 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:** `T` — the cached or freshly stringified value.
+
+```javascript
+import { CacheStatic } from '@dxtmisha/functional'
+
+// File A.js
+function calculateHeavyData(id) {
+  return CacheStatic.get(
+    `heavy_data_${id}`,
+    () => {
+      console.log('Calculating...')
+      return id * 100
+    },
+    [id] // Dependency
+  )
+}
+
+// Will log 'Calculating...' and return 500
+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) 
+```

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

@@ -0,0 +1,53 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Classes/CacheStatic - Быстрый глобальный кэш'/>
+
+# Класс CacheStatic
+
+Класс-обертка, предоставляющий глобально доступный статический экземпляр кэша. Он позволяет выполнять операции быстрого кэширования в любом месте во время выполнения кода без необходимости создавать экземпляр или передавать объект `Cache`.
+
+## Ключевые особенности
+
+- **Глобальный доступ** — работает как паттерн «одиночка» (singleton), используя статические методы. Это означает, что один и тот же пул кэша доступен во всем контексте приложения.
+- **Базовый механизм** — внутренне делегирует все вызовы стандартному экземпляру `Cache`, предоставляя вам те же преимущества отслеживания зависимостей и ленивых вычислений.
+- **Удобство** — идеально подходит для простых требований кэширования общих данных в нескольких не связанных между собой компонентах.
+
+
+Поскольку все методы `static`, вам никогда не нужно вызывать `new CacheStatic()`. Вы взаимодействуете с классом напрямую.
+
+## Глобальное кэширование
+
+### `get`
+
+Используйте статический метод `get()` для получения кэшированного значения или его вычисления при отсутствии.
+
+**Параметры:**
+- `name: string` — уникальный идентификатор для вашей записи в глобальном кэше.
+- `callback: () => T` — функция, которая вычисляет значение.
+- `comparison?: any[]` — опциональный массив зависимостей. Передача нового массива (где значения или длина отличаются) очищает кэш и вызывает пересчет.
+
+**Возвращает:** `T` — закэшированное или вычисленное значение.
+
+```javascript
+import { CacheStatic } from '@dxtmisha/functional'
+
+// Файл A.js
+function calculateHeavyData(id) {
+  return CacheStatic.get(
+    `heavy_data_${id}`,
+    () => {
+      console.log('Вычисляем...')
+      return id * 100
+    },
+    [id] // Зависимость
+  )
+}
+
+// Выведет 'Вычисляем...' и вернет 500
+const res1 = calculateHeavyData(5) 
+
+// Файл B.js
+// Та же функция, тот же id. Попадает в глобальный кэш.
+// НЕ будет выводить 'Вычисляем...', мгновенно вернет 500
+const res2 = calculateHeavyData(5) 
+```

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

@@ -0,0 +1,53 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Classes/CacheStatic - Bộ nhớ đệm tĩnh (Global)'/>
+
+# Lớp CacheStatic
+
+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
+
+- **Lưu Cục Bộ Toàn Phân (Global Accessibility)** — mô hình kết nối hoạt động giống singleton thông qua thiết kế pattern là stactic method. Code định dạng luôn chung vùng bộ nhớ, đảm bảo kết nối giữa nhiều lớp dữ liệu đồng thời suốt hệ thống ứng dụng.
+- **Cơ Chế Phân Định Ngầm** — phần cốt lõi bên trong lớp bọc được nạp một phương thức tham chiếu kế thừa thẳng cấu trúc từ đối tượng `Cache` tiêu chuẩn. Toàn bộ hiệu ứng phụ của `Cache` bao gồm: Cập nhật dependency, lazy loading/lazy evulation,... đều hoạt động trơn tru.
+- **Tính Tiện Dụng** — tiện lợi tuyệt đối, phù hợp với hệ module/chia sẻ component liên kết đơn giản mà không sinh ra phụ thuộc hay tính kế thừa vòng lặp phức tạp trong cây component.
+
+
+Về cấu trúc class, tất cả hàm nội bộ gắn định danh `static`. Hệ quả là hệ thống sẽ chặn không cho sử dụng trình khởi tạo `new CacheStatic()`. Người code sử dụng những hàm này theo cấu trúc thực thi trực tiếp từ class gốc thông qua dấu châm (`.`).
+
+## Lưu trữ cache toàn cục
+
+### `get`
+
+Hàm chức năng `get()` có vai trò lặp tìm phần tử hiện có từ bộ đệm, nếu đối chiếu ra null hoặc undefined nó tự động chạy logic tải và sinh phần tử cache mới thay vào vị trí truy vấn hiện tại.
+
+**Tham số:**
+- `name: string` — biến gán để tạo lập index/luồng đối chiếu cho bộ nhớ định tuyến global hiện tại.
+- `callback: () => T` — các khối lệnh đóng trong tham chiếu được xử lý thông qua biến này.
+- `comparison?: any[]` — danh sách các đối tượng thay đổi, hay dependency list. Khi chạy hàm, node `CacheItem` sẽ đánh mất tình trạng (invalidation) nếu phát hiện bất kì thông số phụ bị sửa bằng biến mảng thay thế (`comparison`).
+
+**Trả về:** `T` — biến được gọi là static cache block.
+
+```javascript
+import { CacheStatic } from '@dxtmisha/functional'
+
+// Mảng A.js
+function calculateHeavyData(id) {
+  return CacheStatic.get(
+    `heavy_data_${id}`,
+    () => {
+      console.log('Calculating...')
+      return id * 100
+    },
+    [id] // Biến phụ thuộc (Dependency)
+  )
+}
+
+// Báo lệnh 'Calculating...' sinh kết quả 500
+const res1 = calculateHeavyData(5) 
+
+// Mảng B.js
+// Trỏ vào chung dữ liệu id 5, chạy tiếp xúc trực tiếp global cache
+// Không thực thi lại callback 'Calculating...', kết xuất liền giá trị 500.
+const res2 = calculateHeavyData(5) 
+```

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

@@ -0,0 +1,87 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Classes/Cookie - Cookie Management'/>
+
+# Cookie Class
+
+A seamless, stateful wrapper for managing browser cookies. It automatically syncs between memory and the `document.cookie` DOM API, allowing you to reactively set, retrieve, and delete cookies while ensuring consistent fallback values.
+
+## Key Features
+
+- **Memory Sync** — maintains an in-memory record of cookies to prevent unnecessary DOM traversals. Automatically parses `document.cookie` on startup.
+- **Environment Aware** — detects if it is running in a DOM environment. In SSR (Server-Side Rendering) or testing (non-DOM), it elegantly degrades to memory-only storage without throwing errors.
+- **Global Blocking Control** — integrates securely with `CookieBlock`. If cookie writing is globally disabled (e.g., due to user privacy consent), the `Cookie` class respects this and suspends all outgoing DOM changes.
+- **Default/Fallback Logic** — getting a value can lazily initialize it with a default standard if it doesn't already exist.
+
+## Initialization
+
+To initialize the object, call the `Cookie(name)` constructor.
+
+**Parameters:**
+- `name: string` — the name of the cookie you want to manage.
+
+```typescript
+import { Cookie } from '@dxtmisha/functional'
+
+// 1. Initialize wrapper for the 'theme' cookie
+const themeCookie = new Cookie('theme')
+```
+
+## Data Management
+
+### `get`
+
+Use `get()` to read the cookie. If you pass a default value to `get()`, it will simultaneously save that default if the cookie was previously unset.
+
+**Parameters:**
+- `value?: T | string | (() => T | string)` — optional default value or a function returning it.
+
+**Returns:** `T | string | undefined` — the value from the cookie, or the assigned default.
+
+```javascript
+// Will read 'theme', OR set and return 'dark' if it doesn't exist
+const currentTheme = themeCookie.get('dark') 
+```
+
+### `set`
+
+Use `set()` to override or create new data. Options allow you to control standard cookie attributes like `age` (Max-Age cache duration in seconds) or `sameSite` policy.
+
+**Parameters:**
+- `value: T | string | (() => T | string)` — the value to store, or a function returning the value.
+- `options?: CookieOptions` — configuration for the cookie lifetime and security.
+
+```javascript
+const userPrefs = new Cookie('preferences')
+
+// Set a simple string
+userPrefs.set('{"compact": true}')
+
+// Set with advanced options
+userPrefs.set('{"compact": true}', {
+  age: 60 * 60 * 24 * 30, // 30 days
+  sameSite: 'lax'
+})
+```
+
+### `remove`
+
+Removing a cookie overwrites it with an empty string and sets its Max-Age to `-1`, instructing the browser to instantly delete the record.
+
+```javascript
+userPrefs.remove()
+```
+
+## Synchronization
+
+- `updateData(): void` (static) — Updates data from `document.cookie`.
+
+## CookieOptions
+
+`CookieOptions` is a configuration object for the `get` and `set` methods:
+
+- `age?: number` — cookie lifetime in **seconds** (`Max-Age` attribute). Default: 7 days (604800 sec). Automatically set to `-1` when deleting via `remove()`.
+- `sameSite?: 'strict' | 'lax'` — the `SameSite` policy. Default: `'strict'` (cookie is only sent on same-site navigations). `'lax'` also allows sending on cross-site GET requests.
+- `arguments?: string[]` — additional directives appended to the cookie string (e.g. `'Secure'`, `'Path=/'`, `'Domain=.myapp.com'`).
+
+