@dxtmisha/wiki 0.39.6 → 0.39.8

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

@@ -4,54 +4,75 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 # Класс CookieBlock
 
-Статический служебный класс, который служит глобальным "аварийным выключателем" для изменений куки в DOM. Он предоставляет простое логическое состояние, которое другие классы, в частности `Cookie`, проверяют перед попыткой записи в `document.cookie`.
+Статический служебный класс, служащий глобальным "аварийным выключателем" для изменений куки в DOM. Предоставляет простое логическое состояние, которое другие классы, в частности `Cookie`, проверяют перед попыткой записи в `document.cookie`.
+
+Включает тесную интеграцию с `ServerStorage` для изоляции состояния между запросами в SSR окружении.
 
 ## Ключевые особенности
 
-- **Глобальная истина** — единая точка конфигурации для остановки операций с куки в масштабах всего приложения.
-- **Соответствие конфиденциальности** — крайне полезно для реализации баннеров "Согласие на использование файлов cookie". Просто установите блокировку в `true`, пока пользователь явно не примет все куки.
-- **Поддержка DataStorage** — внутренне использует абстракцию `DataStorage` для надежного поддержания заблокированного состояния.
+- **Глобальная истина** — единая точка конфигурации для остановки операций с куки в масштабах всего приложения
+- **Соответствие конфиденциальности** — крайне полезно для реализации баннеров "Согласие на использование файлов cookie"
+- **SSR-совместимость** — использует `ServerStorage` для надежного поддержания заблокированного состояния в изолированном контексте каждого запроса
 
+## Статические методы
 
-Поскольку все методы `static`, вы взаимодействуете с классом напрямую.
+### Действие
 
-## Управление доступом
+#### `set`
 
-### `get`
+Включает или отключает возможности записи куки в DOM. При значении `true` все операции записи будут сохранять данные только в памяти, не затрагивая `document.cookie`.
 
-Используйте метод `get()` для чтения текущего статуса блокировки. Возвращает логическое значение.
+**Параметры:**
+- `value: boolean` — `true` для блокировки записи куки, `false` для разрешения
 
-**Возвращает:** `boolean` — `true`, если запись куки заблокирована.
+**Возвращает:** `void`
 
-```javascript
-if (CookieBlock.get()) {
-  console.log('Запись куки в настоящее время заблокирована настройками пользователя.')
-}
-```
+### Проверка
 
-### `set`
+- `get(): boolean` — Возвращает текущий статус блокировки. `true`, если запись куки заблокирована
 
-Используйте метод `set()` для включения или отключения возможностей записи куки.
+## Примеры
 
-**Параметры:**
-- `value: boolean` — `true` для блокировки записи куки, `false` для разрешения.
+### Базовое использование
 
-```javascript
+```typescript
 import { CookieBlock } from '@dxtmisha/functional'
 
-// Заблокировать все будущие записи куки в DOM
+// Блокировать все будущие записи куки в DOM
 CookieBlock.set(true)
 
-// Разрешить записи куки в DOM (поведение по умолчанию)
+if (CookieBlock.get()) {
+  console.log('Запись куки в настоящее время заблокирована')
+}
+
+// Разрешить записи куки в DOM
 CookieBlock.set(false)
 ```
 
+### Реализация баннера согласия
+
+```typescript
+import { CookieBlock, Cookie } from '@dxtmisha/functional'
+
+// При загрузке приложения блокируем cookie
+CookieBlock.set(true)
+
+// После принятия пользователем
+function onCookieConsentAccepted() {
+  CookieBlock.set(false)
+  
+  // Теперь можно устанавливать cookie
+  const theme = new Cookie('theme')
+  theme.set('dark')
+}
+```
+
 ## Как это взаимодействует с `Cookie`
 
 Базовый класс `Cookie` строго следит за этой блокировкой. Если `CookieBlock.get()` возвращает `true`:
 
-1.  Логика вашего приложения технически все еще может вызывать `cookieInstance.set('value')`.
-2.  Экземпляр `Cookie` обновит свое *внутреннее хранилище в памяти* новым значением.
-3.  Экземпляр `Cookie` **молча откажется** от фактической записи в DOM `document.cookie = ...`. 
+1. Логика приложения может технически вызывать `cookieInstance.set('value')`
+2. Экземпляр `Cookie` обновит свое *внутреннее хранилище в памяти* новым значением
+3. Экземпляр `Cookie` **молча откажется** от фактической записи в DOM `document.cookie = ...`
 
-Это гарантирует, что ваше приложение не сломается от неопределенных чтений в памяти, при этом строго соблюдая настройки браузера по сохранению на диск.
+Это гарантирует, что приложение не сломается от неопределенных чтений в памяти, при этом строго соблюдая настройки браузера по сохранению на диск.

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

@@ -6,52 +6,73 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 Lớp tiện ích static dùng để định nghĩa quy luật truy cập ("kill switch" hoặc cầu dao tổng) nhắm thẳng vào quá trình hệ thống có cho phép chỉnh/sửa nội dung DOM cookie trên website hay không. Bằng cách thiết lập chuẩn khoá chặn (boolean logic), các node class lớn hơn (ví dụ Class gốc `Cookie`) sẽ liên tục móc và lắng nghe lệnh này trước khi tiến hành bước in/thực thi ghi data vào `document.cookie`.
 
+Bao gồm tích hợp chặt chẽ với `ServerStorage` để cách ly trạng thái giữa các yêu cầu trong SSR.
+
 ## Các tính năng chính
 
-- **Chấp Nhận Quy Trình Định Mức Chung (Global Truth)** — cổng tuỳ chỉnh/kiểm soát chung đối với quá trình lưu tạo/in cookie dọc toàn bộ mã lệnh ứng dụng.
-- **Chuẩn Cấu Hình Quyền Riêng Tư Đặc thù (Privacy Compliance)** — một mẫu logic tuyệt vời dùng lập trình những phần banner xác nhận "Cookie Consent" (Xin quyền nạp Tracking). Người code chỉ việc nối logic nút bật class thành giá trị `true` đến chừng nào user chốt chấp nhận quy tắc lấy thông tin ở nút 'Đồng Ý'.
-- **Class Truy Vấn Cải Biên (DataStorage Backed)** — vận hành chuẩn dữ liệu `DataStorage` qua cấp độ trừu tượng để việc chặn ghi được tối ưu thông lượng trong background, gia tăng tính tin cậy.
+- **Chấp Nhận Quy Trình Định Mức Chung (Global Truth)** — cổng tuỳ chỉnh/kiểm soát chung đối với quá trình lưu tạo/in cookie dọc toàn bộ mã lệnh ứng dụng
+- **Chuẩn Cấu Hình Quyền Riêng Tư Đặc thù (Privacy Compliance)** — một mẫu logic tuyệt vời dùng lập trình những phần banner xác nhận "Cookie Consent" (Xin quyền nạp Tracking). Người code chỉ việc nối logic nút bật class thành giá trị `true` đến chừng nào user chốt chấp nhận quy tắc lấy thông tin ở nút 'Đồng Ý'
+- **SSR-совместимость** — sử dụng `ServerStorage` để duy trì trạng thái chặn đáng tin cậy trong bối cảnh yêu cầu cách ly
 
+## Phương thức tĩnh
 
-Tất cả là lớp static nên bạn chạy lệnh trượt và trỏ trực tiếp bằng dấu chấm (`.`).
+### Hành động
 
-## Quản lý quyền truy cập
+#### `set`
 
-### `get`
+Bật hoặc tắt khả năng ghi cookie. Khi đặt thành `true`, tất cả hoạt động ghi sẽ chỉ lưu dữ liệu trong bộ nhớ, không chạm đến `document.cookie`.
 
-`get()` trả về 100% chuẩn cấu trúc kiểu nhị phân boolean.
+**Tham số:**
+- `value: boolean` — `true` để chặn ghi cookie, `false` để cho phép
 
-**Trả về:** `boolean` — `true` nếu trình kiểm duyệt khóa chức năng tạo cookie.
+**Trả về:** `void`
 
-```javascript
-if (CookieBlock.get()) {
-  console.log('Quá trình nạp DOM/ghi chép Cookie đang khoá do cài đặt phía user chưa cho quyền truy cập.')
-}
-```
+### Kiểm tra
 
-### `set`
+- `get(): boolean` — Trả về trạng thái chặn hiện tại. `true` nếu ghi cookie bị chặn
 
-Truy vấn tham số boolean qua `set()` để class hiểu website/app được hay không thể được viết biến cache cookie nữa.
+## Ví dụ
 
-**Tham số:**
-- `value: boolean` — `true` đồng nghĩa chặn toàn bộ biến muốn viết cookie ra ngoài trỏ lên web, `false` hệ thống lại bật tắt mượt mà bình thường.
+### Sử dụng cơ bản
 
-```javascript
+```typescript
 import { CookieBlock } from '@dxtmisha/functional'
 
 // Lệnh chặn khẩn cấp toàn bộ dữ liệu ghi DOM cookie
 CookieBlock.set(true)
 
+if (CookieBlock.get()) {
+  console.log('Quá trình nạp DOM/ghi chép Cookie đang khoá do cài đặt phía user chưa cho quyền truy cập.')
+}
+
 // Dỡ bỏ cảnh bảo / Cấp quyền DOM in cookie (Cấu hình chuẩn của object mới)
 CookieBlock.set(false)
 ```
 
-## Phương Phức Logic Khi Mắc Nối Với Lớp `Cookie`
+### Triển khai banner đồng ý
+
+```typescript
+import { CookieBlock, Cookie } from '@dxtmisha/functional'
+
+// Chặn cookie khi tải ứng dụng
+CookieBlock.set(true)
+
+// Sau khi người dùng đồng ý
+function onCookieConsentAccepted() {
+  CookieBlock.set(false)
+  
+  // Bây giờ có thể đặt cookie
+  const theme = new Cookie('theme')
+  theme.set('dark')
+}
+```
+
+## Phương thức logic khi mắc nối với lớp `Cookie`
 
 Nhân/Bộ cấu trúc tổng của class `Cookie` được code giám sát nghiêm ngặt mọi lệnh do luồng chặn phát đi. Lúc biến nhị phân `CookieBlock.get()` bị chốt ở mode `true`:
 
-1.  Ở nội bộ luồng mã, quá trình chạy vẫn ngầm hiểu là hệ thống gọi app bằng node lưu biến `cookieInstance.set('value')`.
-2.  Tiến trình instance trực thuộc `Cookie` kích hoạt việc in giá trị cập nhật/ghi đè thay thế nằm vào hàng đợi của *cơ sở memory ảo* (internal memory).
-3.  Tuyệt nhiên tại chính node instance của `Cookie` **hệ thống tự phát sinh quyền bác bỏ im lặng (silently refuse)** đối với hàm ghi biến tĩnh `document.cookie = ...` tại nhánh DOM ảo lẫn DOM thật.
+1. Ở nội bộ luồng mã, quá trình chạy vẫn ngầm hiểu là hệ thống gọi app bằng node lưu biến `cookieInstance.set('value')`
+2. Tiến trình instance trực thuộc `Cookie` kích hoạt việc in giá trị cập nhật/ghi đè thay thế nằm vào hàng đợi của *cơ sở memory ảo* (internal memory)
+3. Tuyệt nhiên tại chính node instance của `Cookie` **hệ thống tự phát sinh quyền bác bỏ im lặng (silently refuse)** đối với hàm ghi biến tĩnh `document.cookie = ...` tại nhánh DOM ảo lẫn DOM thật
 
 Luồng giao thức 3 buớc phía trên đáp ứng hoàn hảo hai tiêu chí tối thượng trong quy chuẩn kỹ thuật: Giúp DOM website không bị bóp băng thông khi chạy lỗi code lấy lệnh từ hệ memory chưa cấp dữ liệu (ngăn văng bug), cũng như giữ thiết lập tôn trọng chính sách truy vấn riêng tư bảo mật đĩa cứng phía Browser theo chuẩn Âu/Mỹ.

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

@@ -0,0 +1,84 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Classes/CookieBlockInstance - Cookie Access Status Instance'/>
+
+# CookieBlockInstance Class
+
+The `CookieBlockInstance` class is responsible for managing the cookie access status at the instance level. It provides a localized state for blocking or allowing cookie operations, which is essential for request isolation in Server-Side Rendering (SSR) or when multiple independent contexts are required.
+
+Includes tight integration with `DataStorage` for reliable state persistence.
+
+## Key Features
+
+- **Instance-Based** — allows creating separate instances with their own block status
+- **DataStorage Integration** — automatically persists the block status using the `DataStorage` class
+- **SSR Compatible** — designed to work seamlessly in server-side environments by leveraging the singleton-per-request pattern when wrapped by `CookieBlock`
+
+## Methods
+
+### Action
+
+#### `set`
+
+Updates the cookie access status. When set to `true`, blocks all cookie write operations within this instance's context.
+
+**Parameters:**
+- `value: boolean` — the new status to set
+
+### Check
+
+- `get(): boolean` — Returns the current cookie access status. `true` if cookies are blocked, `false` otherwise
+
+## Examples
+
+### Basic Usage
+
+```typescript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+const cookieBlock = new CookieBlockInstance()
+
+// Get the current status
+console.log(cookieBlock.get()) // false (default)
+
+// Set status to blocked
+cookieBlock.set(true)
+
+console.log(cookieBlock.get()) // true
+
+// Unblock
+cookieBlock.set(false)
+
+console.log(cookieBlock.get()) // false
+```
+
+### Using via CookieBlock
+
+While `CookieBlockInstance` can be used directly, it is typically accessed through the static `CookieBlock` wrapper:
+
+```typescript
+import { CookieBlock } from '@dxtmisha/functional-basic'
+
+// CookieBlock automatically creates an isolated instance for each request
+CookieBlock.set(true)
+
+// Status is accessible through static methods
+if (CookieBlock.get()) {
+  console.log('Cookies are blocked in the current context')
+}
+```
+
+### Independent Contexts
+
+```typescript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+// Create independent instances
+const block1 = new CookieBlockInstance()
+const block2 = new CookieBlockInstance()
+
+block1.set(true)
+
+console.log(block1.get()) // true
+console.log(block2.get()) // false (independent instance)
+```

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

@@ -0,0 +1,84 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Classes/CookieBlockInstance - Экземпляр статуса доступа к куки'/>
+
+# Класс CookieBlockInstance
+
+Класс `CookieBlockInstance` отвечает за управление статусом доступа к куки на уровне экземпляра. Предоставляет локализованное состояние для блокировки или разрешения операций с куки, что необходимо для изоляции запросов в Server-Side Rendering (SSR) или когда требуются несколько независимых контекстов.
+
+Включает тесную интеграцию с `DataStorage` для надежного сохранения статуса.
+
+## Ключевые особенности
+
+- **На основе экземпляров** — позволяет создавать отдельные экземпляры с их собственным статусом блокировки
+- **Интеграция с DataStorage** — автоматически сохраняет статус блокировки, используя класс `DataStorage`
+- **Совместимость с SSR** — разработан для бесшовной работы в серверных средах, используя паттерн "один экземпляр на запрос" при использовании через обертку `CookieBlock`
+
+## Методы
+
+### Действие
+
+#### `set`
+
+Обновляет статус доступа к куки. При значении `true` блокирует все операции записи с куки в контексте этого экземпляра.
+
+**Параметры:**
+- `value: boolean` — новый статус для установки
+
+### Проверка
+
+- `get(): boolean` — Возвращает текущий статус доступа к куки. `true`, если куки заблокированы, иначе `false`
+
+## Примеры
+
+### Базовое использование
+
+```typescript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+const cookieBlock = new CookieBlockInstance()
+
+// Получить текущий статус
+console.log(cookieBlock.get()) // false (по умолчанию)
+
+// Заблокировать куки
+cookieBlock.set(true)
+
+console.log(cookieBlock.get()) // true
+
+// Разблокировать куки
+cookieBlock.set(false)
+
+console.log(cookieBlock.get()) // false
+```
+
+### Использование через CookieBlock
+
+Хотя `CookieBlockInstance` можно использовать напрямую, обычно к нему обращаются через статическую обертку `CookieBlock`:
+
+```typescript
+import { CookieBlock } from '@dxtmisha/functional-basic'
+
+// CookieBlock автоматически создает изолированный экземпляр для каждого запроса
+CookieBlock.set(true)
+
+// Статус доступен через статические методы
+if (CookieBlock.get()) {
+  console.log('Куки заблокированы в текущем контексте')
+}
+```
+
+### Независимые контексты
+
+```typescript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+// Создание независимых экземпляров
+const block1 = new CookieBlockInstance()
+const block2 = new CookieBlockInstance()
+
+block1.set(true)
+
+console.log(block1.get()) // true
+console.log(block2.get()) // false (независимый экземпляр)
+```

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

@@ -0,0 +1,100 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Classes/CookieBlockInstance - Phiên bản trạng thái truy cập Cookie'/>
+
+# Lớp CookieBlockInstance
+
+Lớp `CookieBlockInstance` chịu trách nhiệm quản lý trạng thái truy cập cookie ở cấp độ phiên bản (instance). Nó cung cấp một trạng thái cục bộ để chặn hoặc cho phép các thao tác cookie, điều này rất quan trọng để cách ly các yêu cầu trong Server-Side Rendering (SSR) hoặc khi cần nhiều ngữ cảnh độc lập.
+
+Bao gồm tích hợp chặt chẽ với `DataStorage` để lưu trữ trạng thái chặn đáng tin cậy.
+
+## Các tính năng chính
+
+- **Dựa trên phiên bản (Instance-Based)** — cho phép tạo các phiên bản riêng biệt với trạng thái chặn của riêng chúng
+- **Tích hợp DataStorage** — tự động lưu trữ trạng thái chặn bằng cách sử dụng lớp `DataStorage`
+- **Tương thích với SSR** — được thiết kế để hoạt động trơn tru trong môi trường phía máy chủ bằng cách tận dụng mô hình singleton-mỗi-yêu-cầu khi được bao bọc bởi `CookieBlock`
+
+## Phương thức
+
+### Hành động
+
+#### `set`
+
+Cập nhật trạng thái truy cập cookie. Khi đặt thành `true`, chặn tất cả hoạt động ghi cookie trong ngữ cảnh của phiên bản này.
+
+**Tham số:**
+- `value: boolean` — trạng thái mới cần thiết lập
+
+### Kiểm tra
+
+- `get(): boolean` — Trả về trạng thái truy cập cookie hiện tại. `true` nếu cookie bị chặn, `false` nếu ngược lại
+
+## Cách sử dụng cơ bản
+
+Mặc dù `CookieBlockInstance` có thể được sử dụng trực tiếp, nhưng thông thường nó được truy cập thông qua lớp bọc tĩnh `CookieBlock`. Tuy nhiên, đối với logic chuyên biệt, bạn có thể khởi tạo nó theo cách thủ công:
+
+```javascript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+const cookieBlock = new CookieBlockInstance()
+
+// Lấy trạng thái hiện tại
+console.log(cookieBlock.get()) // false (mặc định)
+
+// Đặt trạng thái thành bị chặn
+cookieBlock.set(true)
+
+console.log(cookieBlock.get()) // true
+```
+
+## Ví dụ
+
+### Sử dụng trực tiếp
+
+```typescript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+const cookieBlock = new CookieBlockInstance()
+
+// Lấy trạng thái hiện tại
+console.log(cookieBlock.get()) // false (mặc định)
+
+// Đặt trạng thái thành bị chặn
+cookieBlock.set(true)
+
+console.log(cookieBlock.get()) // true
+
+// Mở chặn
+cookieBlock.set(false)
+
+console.log(cookieBlock.get()) // false
+```
+
+### Sử dụng qua CookieBlock
+
+```typescript
+import { CookieBlock } from '@dxtmisha/functional-basic'
+
+// CookieBlock tự động tạo phiên bản cách ly cho mỗi yêu cầu
+CookieBlock.set(true)
+
+// Trạng thái có thể truy cập qua các phương thức tĩnh
+if (CookieBlock.get()) {
+  console.log('Cookies bị chặn trong ngữ cảnh hiện tại')
+}
+```
+
+### Ngữ cảnh độc lập
+
+```typescript
+import { CookieBlockInstance } from '@dxtmisha/functional-basic'
+
+// Tạo các phiên bản độc lập
+const block1 = new CookieBlockInstance()
+const block2 = new CookieBlockInstance()
+
+block1.set(true)
+
+console.log(block1.get()) // true
+console.log(block2.get()) // false (phiên bản độc lập)
+```

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

@@ -0,0 +1,153 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Classes/CookieStorage - Cookie Storage'/>
+
+# CookieStorage Class
+
+A class for managing cookie storage with support for custom listeners. Provides a low-level interface for working with cookies in different environments (DOM, SSR) with automatic type parsing and secure data handling.
+
+Includes tight integration with `CookieBlock` for access control and supports URL-encoded value decoding.
+
+## Key Features
+
+- **Flexible Storage** — supports in-memory storage and external storage mechanisms through listeners
+- **Automatic Parsing** — intelligently converts string values to appropriate data types
+- **Block Integration** — respects global write blocking via `CookieBlock`
+- **Environment Awareness** — automatically detects DOM environment and adapts behavior
+- **URL Decoding** — automatically decodes names and values when reading from DOM
+
+## Static Methods
+
+### Action
+
+#### `get`
+
+Retrieves a cookie value by name with automatic type conversion. If the value doesn't exist and a default is provided, it will be set and stored.
+
+**Parameters:**
+- `name: string` — the cookie name
+- `defaultValue?: T | (() => T)` — default value or function returning the value
+
+**Returns:** `T | undefined` — the converted cookie value or default value
+
+#### `set`
+
+Stores a cookie value with specified options and automatically updates both memory and DOM. If blocking is active via `CookieBlock`, the value is stored in memory only.
+
+**Parameters:**
+- `name: string` — the cookie name
+- `value: T | (() => T)` — the value or a function returning the value
+- `options?: CookieOptions` — additional cookie options
+
+**Returns:** `T` — the stored value
+
+#### `remove`
+
+Removes a cookie by setting an empty value and negative expiration. Equivalent to calling `set(name, '', { age: -1 })`.
+
+**Parameters:**
+- `name: string` — the cookie name
+
+### Configuration
+
+- `init(getListener, setListener)` — Initializes the storage with custom listeners for reading and writing data
+- `reset()` — Resets the storage by clearing all in-memory items and removing listeners
+
+### Auxiliary
+
+- `update()` — Updates in-memory data by parsing values from `document.cookie`
+
+## Types
+
+### `CookieOptions`
+
+Configuration object for cookie parameters:
+
+- `age?: number` — lifetime in seconds (Max-Age attribute)
+- `sameSite?: 'strict' | 'lax'` — SameSite policy
+- `arguments?: string[]` — additional directives for the cookie string
+
+## Built-in Type Conversion
+
+`CookieStorage` automatically converts string values when reading:
+
+- `'undefined'` → `undefined`
+- `'null'` → `null`
+- `'true'` → `true`
+- `'false'` → `false`
+- `'123'` → `123` (number)
+- `'{"key":"value"}'` → `{key: 'value'}` (JSON object)
+
+## Examples
+
+### Basic Usage
+
+```typescript
+import { CookieStorage } from '@dxtmisha/functional-basic'
+
+// Get with default value
+const theme = CookieStorage.get<string>('theme', 'dark')
+
+// Store value
+CookieStorage.set('user', 'john', {
+  age: 3600,
+  sameSite: 'lax'
+})
+
+// Remove
+CookieStorage.remove('user')
+```
+
+### Initialize with External Storage
+
+```typescript
+import { CookieStorage } from '@dxtmisha/functional-basic'
+
+CookieStorage.init(
+  (key) => myStorage.get(key),
+  (key, value, options) => myStorage.set(key, value, options)
+)
+```
+
+### Update and Reset
+
+```typescript
+import { CookieStorage } from '@dxtmisha/functional-basic'
+
+// Update in-memory data from document.cookie
+// Useful when cookies were set externally
+CookieStorage.update()
+
+// Reset storage (clear listeners and in-memory data)
+// Useful for testing or cleanup
+CookieStorage.reset()
+```
+
+### Complete Workflow
+
+```typescript
+import { CookieStorage } from '@dxtmisha/functional-basic'
+
+// Initialize with custom storage
+CookieStorage.init(
+  (key) => redis.get(key),
+  (key, value, options) => redis.set(key, value, options)
+)
+
+// Set value with options
+CookieStorage.set('user', 'john', {
+  age: 3600,           // 1 hour
+  sameSite: 'lax',     // SameSite policy
+  arguments: ['Secure', 'Path=/'] // Additional directives
+})
+
+// Get with type conversion
+const user = CookieStorage.get<string>('user')
+
+// Update from external source
+CookieStorage.update()
+
+// Clean up
+CookieStorage.remove('user')
+CookieStorage.reset()
+```