@dxtmisha/wiki 0.39.7 → 0.39.8

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

@@ -2,94 +2,125 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 <Meta title='@dxtmisha/vi/functional-basic/Classes/ErrorCenter - Quản lý lỗi'/>
 
-# ErrorCenter
+# Lớp ErrorCenter
 
-Một lớp tĩnh (static wrapper) cho `ErrorCenterInstance` cung cấp quản lý tập trung cho việc lưu trữ, truy xuất và xử lý lỗi dựa trên sự kiện. Nó đóng vai trò như một bộ lưu trữ toàn cầu cho các nguyên nhân gây lỗi và cung cấp cơ chế để đăng ký cũng như kích hoạt các trình xử lý tùy chỉnh cho các nhóm lỗi khác nhau.
+`ErrorCenter` là công cụ trung tâm để quản lý tất cả các lỗi trong ứng dụng. Nó cho phép bạn đăng ký các nguyên nhân lỗi có thể xảy ra ở một nơi, cấu hình phản ứng với chúng (ví dụ: hiển thị thông báo) và kích hoạt chúng từ bất kỳ phần nào của mã.
 
-Lớp này tuân theo mô hình "Static Bridge", chuyển giao tất cả các hoạt động cho một thực thể duy nhất (singleton instance) trong khi vẫn duy trì một API sạch sẽ, có thể truy cập toàn cầu.
+Lớp này hoạt động như một vỏ bọc tĩnh (Static Bridge), chuyển tất cả các yêu cầu đến một `ErrorCenterInstance` duy nhất.
 
-## Các tính năng chính
+## Các phương thức
 
-- **Truy cập tĩnh** — Truy cập toàn cầu vào quản lý lỗi mà không cần khởi tạo thủ công.
-- **Bộ lưu trữ tập trung** — Lưu trữ các nguyên nhân lỗi được tiêu chuẩn hóa để phản hồi UI nhất quán.
-- **Xử lý theo nhóm** — Cho phép đăng ký nhiều hàm gọi lại cho các danh mục lỗi cụ thể.
-- **Chainable API** — Các phương thức thêm nguyên nhân và trình xử lý hỗ trợ thiết kế giao diện linh hoạt.
-- **Giá trị mặc định** — Đi kèm với các nguyên nhân lỗi mạng tiêu chuẩn (`timeout`, `offline`, `notFound`, v.v.).
+### Hành động
+- `on(cause: ErrorCenterCauseItem): void` — Bắt đầu quá trình xử lý. Tìm kiếm dữ liệu trong sổ đăng ký, hợp nhất chúng và gọi các callback thích hợp.
 
-## Các phương thức kiểm tra
+### Xác minh
+- `has(code: string, group?: string): boolean` — Kiểm tra xem lỗi đã được đăng ký chưa.
+- `get(code: string, group?: string): ErrorCenterCauseItem | undefined` — Trả về dữ liệu lỗi từ sổ đăng ký.
 
-- `has(code: string, group?: string): boolean` — Kiểm tra xem một nguyên nhân lỗi có tồn tại trong bộ lưu trữ hay không.
-- `get(code: string, group?: string): ErrorCenterCauseItem | undefined` — Truy xuất đối tượng nguyên nhân lỗi đầy đủ.
+### Cấu hình
+- `add(cause: ErrorCenterCauseItem): void` — Thêm một nguyên nhân lỗi.
+- `addList(causes: ErrorCenterCauseList): void` — Thêm một danh sách lỗi (đăng ký hàng loạt).
+- `addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): void` — Đăng ký phản ứng cho một nhóm lỗi.
+- `addHandlerList(handlers: ErrorCenterHandlerList): void` — Đăng ký hàng loạt nhiều trình xử lý.
 
-## Truy xuất thực thể
-
-- `getItem(): ErrorCenterInstance` — Trả về thực thể nền tảng được sử dụng bởi lớp tĩnh.
-
-## Cấu hình
-
-- `add(cause: ErrorCenterCauseItem): this` — Thêm một nguyên nhân lỗi duy nhất vào bộ lưu trữ toàn cầu.
-- `addList(causes: ErrorCenterCauseList): this` — Thêm nhiều nguyên nhân lỗi vào bộ lưu trữ cùng một lúc.
-- `addHandler(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Đăng ký một hàm gọi lại cho một nhóm lỗi cụ thể.
-- `addHandlerList(handlers: ErrorCenterHandlerList): this` — Đăng ký một loạt các trình xử lý.
-
-## Các phương thức hành động
-
-### `on`
-
-Kích hoạt xử lý lỗi cho nguyên nhân được chỉ định. Nó tìm kiếm dữ liệu đã đăng ký trước đó cho mã lỗi (nếu có), hợp nhất với nguyên nhân đầu vào (`cause`), thực thi tất cả các trình xử lý đã đăng ký cho nhóm đó và ghi lỗi vào bảng điều khiển (console).
-
-**Tham số:**
-- `cause: ErrorCenterCauseItem` — Nguyên nhân lỗi cần kích hoạt. Chỉ cần cung cấp mã và nhóm nếu nguyên nhân đó đã được đăng ký trước đó qua `add()`.
-
-**Trả về:** `this`
+### Bổ trợ
+- `getItem(): ErrorCenterInstance` — Trả về thực thể nội bộ của lớp.
 
 ## Các kiểu dữ liệu
 
-### `ErrorCenterCauseItem`
-
-Đối tượng chính được sử dụng để xác định nguyên nhân gây lỗi.
+#### `ErrorCenterGroup`
+Tên nhóm (ví dụ: 'api', 'auth') hoặc `undefined` cho trình xử lý chung.
 
-- `group?: ErrorCenterGroup` — danh mục/nhóm mà lỗi thuộc về.
-- `code: string` — mã định danh duy nhất cho lỗi.
-- `label?: string` — tên lỗi dễ đọc cho người dùng.
-- `message?: string` — mô tả chi tiết về lỗi.
-- `details?: any` — đối tượng tùy chọn cho các dữ liệu bổ sung.
+#### `ErrorCenterCauseItem`
+Đối tượng mô tả lỗi: `group`, `code` (bắt buộc), `priority`, `label`, `message`, `details`.
 
-### `ErrorCenterGroup`
+## Hướng dẫn sử dụng
 
-Định nghĩa kiểu đơn giản để phân loại lỗi: `string | undefined`.
-
-## Các nguyên nhân lỗi mặc định
-
-`ErrorCenter` được điền sẵn tự động với các nguyên nhân mạng tiêu chuẩn sau:
+### Bước 1: Đăng ký (Registry)
+Lập một từ điển lỗi để lưu trữ văn bản tách biệt với mã.
+```typescript
+ErrorCenter.add({
+  group: 'auth',
+  code: 'LOGIN_FAILED',
+  label: 'Đăng nhập thất bại',
+  message: 'Mật khẩu không hợp lệ.'
+})
+```
 
-- `unknown` — **Lỗi không xác định**: Đã xảy ra lỗi không mong muốn. Vui lòng thử lại.
-- `timeout` — **Yêu cầu hết hạn**: Yêu cầu mất quá nhiều thời gian. Vui lòng kiểm tra kết nối.
-- `offline` — **Không có kết nối**: Bạn đang ngoại tuyến. Vui lòng kiểm tra mạng.
-- `notFound` — **Không tìm thấy**: Tài nguyên được yêu cầu không thể tìm thấy.
-- `server` — **Lỗi máy chủ**: Đã xảy ra lỗi nội bộ máy chủ.
+### Bước 2: Đăng ký nhận lỗi (Handlers)
+Chỉ định cách ứng dụng sẽ phản ứng với một nhóm lỗi.
+```typescript
+ErrorCenter.addHandler('auth', (cause) => {
+  alert(cause.message);
+});
+```
 
-## Ví dụ sử dụng
+### Bước 3: Kích hoạt (Execution)
+Kích hoạt lỗi bằng mã và nhóm của nó.
+```typescript
+ErrorCenter.on({ group: 'auth', code: 'LOGIN_FAILED' });
+```
 
-```javascript
+## Nguyên nhân lỗi tiêu chuẩn
+
+Lớp đã chứa các mô tả sẵn có cho các tình huống phổ biến.
+
+#### Nhóm API (`api`)
+Được sử dụng cho các lỗi yêu cầu mạng.
+- **forbidden** — Truy cập bị cấm (403).
+- **notFound** — Không tìm thấy tài nguyên (404).
+- **offline** — Không có kết nối internet.
+- **server** — Lỗi máy chủ nội bộ (500).
+- **timeout** — Hết thời gian yêu cầu.
+- **unauthorized** — Lỗi xác thực (401).
+- **unknown** — Lỗi không xác định.
+- **cacheClear**, **cacheGet**, **cacheRemove**, **cacheSet** — Lỗi khi làm việc với bộ nhớ đệm.
+
+#### Nhóm Intl (`intl`)
+Lỗi trong quá trình định dạng dữ liệu (ngày tháng, số, v.v.).
+- **datetime**, **display**, **number**, **plural**, **relative**.
+- **invalid** — Ngày không hợp lệ hoặc định dạng sai.
+
+#### Nhóm Storage (`storage`)
+Lỗi khi tương tác với bộ lưu trữ cục bộ hoặc máy chủ.
+- **context** — Thiếu ngữ cảnh.
+- **error** — Lỗi đọc/ghi chung.
+
+#### Các nhóm khác
+Các nhóm này sử dụng mã lỗi chung `error`. Việc kích hoạt được thực hiện thông qua `ErrorCenter.on({ group: 'tên_nhóm', code: 'error' })`.
+- **broadcast** — Lỗi trong việc trao đổi dữ liệu giữa các tab trình duyệt.
+- **hydration** — Lỗi trong quá trình đồng bộ hóa dữ liệu giữa máy chủ và máy khách.
+- **share** — Lỗi khi cố gắng chia sẻ nội dung (Sharing API).
+- **transformation** — Lỗi trong quá trình chuyển đổi hoặc phân tích cú pháp dữ liệu.
+
+## Ví dụ
+
+### Tích hợp với hệ thống thông báo
+```typescript
 import { ErrorCenter } from '@dxtmisha/functional-basic'
 
-// 1. Cấu hình trình xử lý toàn cục
+// Thiết lập một lần khi khởi động ứng dụng
 ErrorCenter.addHandler('api', (cause) => {
-  notification.error({
-    title: cause.label,
-    message: cause.message
-  })
-})
-
-// 2. Đăng ký các nguyên nhân lỗi cụ thể
-ErrorCenter.add({
-  group: 'auth',
-  code: 'token_expired',
-  label: 'Phiên làm việc hết hạn',
-  message: 'Vui lòng đăng nhập lại.'
-})
+  Toast.show(cause.label || 'Lỗi', cause.message);
+});
+
+// Sử dụng trong bất kỳ dịch vụ nào
+async function loadData() {
+  try {
+    const data = await fetch('/api');
+  } catch (e) {
+    ErrorCenter.on({ group: 'api', code: 'server', details: e });
+  }
+}
+```
 
-// 3. Kích hoạt lỗi qua mã và nhóm
-ErrorCenter.on({ group: 'auth', code: 'token_expired' })
+### Làm việc với các nhóm tùy chỉnh
+```typescript
+// Đăng ký tức thì
+ErrorCenter.on({
+  group: 'upload',
+  code: 'SIZE_LIMIT',
+  label: 'Tệp quá lớn',
+  message: 'Tối đa 5MB'
+});
 ```

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

@@ -2,68 +2,72 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 <Meta title='@dxtmisha/en/functional-basic/Classes/ErrorCenterHandler - Handler Management'/>
 
-# ErrorCenterHandler
+# ErrorCenterHandler Class
 
-A core utility class for managing and triggering error handlers based on defined groups. It allows for flexible error response strategies, such as showing global notifications for API errors while performing silent logging for background tasks.
+`ErrorCenterHandler` is a manager for handling callback functions (handlers). It allows you to bind logic to specific error groups and execute it when a corresponding event occurs.
 
 ## Key Features
 
-- **Handler Registration** — Easily add multiple callback functions to specific error groups.
-- **Group Filtering** — Target specific categories of errors (e.g., `api`, `auth`, `validation`).
-- **Global Fallback** — Support for an `undefined` group handler that catches any error without a specific handler.
-- **Sequential Execution** — Triggers all registered callbacks for a group in the order they were added.
-- **Integrated Logging** — Automatically outputs error details to the browser console for debugging.
+- **Handler Registration** — convenient addition of callback functions to specific groups.
+- **Global Handler** — support for the `undefined` group, which catches any error without a specific handler.
+- **Sequential Execution** — triggers all registered functions in the order they were added.
+- **Integrated Logging** — automatically outputs error details to the console.
 
-## Check Methods
+## Initialization
 
-- `has(group: ErrorCenterGroup): boolean` — Checks if any handlers are registered for a specific group.
-- `get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined` — Retrieves the handler mapping for a group.
+To create an instance, use the constructor `ErrorCenterHandler(handlers)`.
 
-## Configuration
+**Parameters:**
+- `handlers?: ErrorCenterHandlerList` — initial list of handlers.
 
-- `add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Adds a single callback function to a group.
-- `addList(handlers: ErrorCenterHandlerList): this` — Registers a batch of handlers.
+```typescript
+import { ErrorCenterHandler } from '@dxtmisha/functional-basic'
 
-## Action Methods
+const handlers = new ErrorCenterHandler([
+  {
+    group: 'api',
+    handlers: [(cause) => console.log('API Error:', cause.code)]
+  }
+]);
+```
 
-### `on`
+## Methods
 
-Triggers all registered handlers for the provided error cause's group. If no specific handlers are found, it falls back to the handlers registered for the `undefined` group (if any). Always logs the error details to the console internally.
+### Action
+- `on(cause: ErrorCenterCauseItem): this` — Triggers the chain of handlers. Always outputs an error to the console via `console.error`.
 
-**Parameters:**
-- `cause: ErrorCenterCauseItem` — The error details to pass to handlers.
+### Verification
+- `has(group: ErrorCenterGroup): boolean` — Checks if there are handlers for a group.
+- `get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined` — Returns a list of functions for a group.
 
-**Returns:** `this`
+### Configuration
+- `add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Adds a single function to a group.
+- `addList(handlers: ErrorCenterHandlerList): this` — Batch registration of handlers.
 
 ## Types
 
-### `ErrorCenterHandlerCallback`
+#### `ErrorCenterGroup`
+Group name (`string`) or `undefined` for global interception.
 
-The function signature for error handling callbacks.
+#### `ErrorCenterHandlerCallback`
+Callback function: `(cause: ErrorCenterCauseItem) => void`.
 
-- `(cause: ErrorCenterCauseItem) => void` — Receives the merged error cause object.
-
-## Usage Example
-
-```javascript
-import { ErrorCenterHandler } from '@dxtmisha/functional-basic'
+#### `ErrorCenterHandlerItem`
+Link between a group and an array of its functions.
+- `group?: ErrorCenterGroup` — target group.
+- `handlers: ErrorCenterHandlerCallback[]` — list of functions.
 
-const handlerManager = new ErrorCenterHandler()
+## Examples
 
-// 1. Register a specific group handler
-handlerManager.add('api', (cause) => {
-  console.log('[API Handler]', cause.message)
-})
+### Isolated Manager for a Module
+```typescript
+const uploadHandlers = new ErrorCenterHandler();
 
-// 2. Register a global fallback handler
-handlerManager.add(undefined, (cause) => {
-  console.error('[Global Fallback]', cause.code)
-})
+uploadHandlers.add('upload', (cause) => {
+  if (cause.code === 'retry') {
+    restartUpload();
+  }
+});
 
-// 3. Triggering an error
-handlerManager.on({
-  group: 'api',
-  code: '500',
-  message: 'Internal Server Error'
-})
+uploadHandlers.on({ group: 'upload', code: 'retry' });
 ```

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

@@ -2,68 +2,72 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 <Meta title='@dxtmisha/ru/functional-basic/Classes/ErrorCenterHandler - Управление обработчиками'/>
 
-# ErrorCenterHandler
+# Класс ErrorCenterHandler
 
-Основной вспомогательный класс для управления и вызова обработчиков ошибок на основе определенных групп. Он позволяет реализовывать гибкие стратегии реагирования на ошибки, такие как отображение глобальных уведомлений для ошибок API при выполнении скрытого логирования для фоновых задач.
+`ErrorCenterHandler` — это менеджер для управления функциями обратного вызова (обработчиками). Он позволяет привязывать логику к определенным группам ошибок и выполнять её, когда происходит соответствующее событие.
 
 ## Ключевые особенности
 
-- **Регистрация обработчиков** — Удобное добавление нескольких функций обратного вызова к конкретным группам.
-- **Групповая фильтрация** — Возможность нацеливаться на конкретные категории ошибок.
-- **Глобальный обработчик** — Поддержка группы `undefined`, которая перехватывает любую ошибку без специфического обработчика.
-- **Последовательное выполнение** — Запускает все зарегистрированные функции в порядке их добавления.
-- **Интегрированное логирование** — Автоматически выводит детали ошибки в консоль браузера.
+- **Регистрация обработчиков** — удобное добавление функций обратного вызова к конкретным группам.
+- **Глобальный обработчик** — поддержка группы `undefined`, которая перехватывает любую ошибку без специфического обработчика.
+- **Последовательное выполнение** — запускает все зарегистрированные функции в порядке их добавления.
+- **Интегрированное логирование** — автоматически выводит детали ошибки в консоль.
 
-## Методы проверки
+## Инициализация
 
-- `has(group: ErrorCenterGroup): boolean` — Проверяет, зарегистрированы ли обработчики для группы.
-- `get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined` — Извлекает элемент обработчика для группы.
+Для создания экземпляра используйте конструктор `ErrorCenterHandler(handlers)`.
 
-## Конфигурация
+**Параметры:**
+- `handlers?: ErrorCenterHandlerList` — начальный список обработчиков.
 
-- `add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Добавляет одну функцию обратного вызова в группу.
-- `addList(handlers: ErrorCenterHandlerList): this` — Регистрирует пакет обработчиков.
+```typescript
+import { ErrorCenterHandler } from '@dxtmisha/functional-basic'
 
-## Методы действий
+const handlers = new ErrorCenterHandler([
+  {
+    group: 'api',
+    handlers: [(cause) => console.log('API Error:', cause.code)]
+  }
+]);
+```
 
-### `on`
+## Методы
 
-Запускает все зарегистрированные обработчики для группы предоставленной причины ошибки. Если специфические обработчики не найдены, метод переходит к обработчикам, зарегистрированным для группы `undefined` (если они есть). Всегда выводит детали ошибки в консоль внутри.
+### Действие
+- `on(cause: ErrorCenterCauseItem): this` — Запускает цепочку обработчиков. Всегда выводит ошибку в консоль через `console.error`.
 
-**Параметры:**
-- `cause: ErrorCenterCauseItem` — Детали ошибки для передачи обработчикам.
+### Проверка
+- `has(group: ErrorCenterGroup): boolean` — Проверяет, есть ли обработчики для группы.
+- `get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined` — Возвращает список функций для группы.
 
-**Возвращает:** `this`
+### Конфигурация
+- `add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Добавляет одну функцию в группу.
+- `addList(handlers: ErrorCenterHandlerList): this` — Пакетная регистрация обработчиков.
 
 ## Типы
 
-### `ErrorCenterHandlerCallback`
+#### `ErrorCenterGroup`
+Имя группы (`string`) или `undefined` для глобального перехвата.
 
-Сигнатура функции для обратных вызовов обработки ошибок.
+#### `ErrorCenterHandlerCallback`
+Функция обратного вызова: `(cause: ErrorCenterCauseItem) => void`.
 
-- `(cause: ErrorCenterCauseItem) => void` — получает объединенный объект причины ошибки.
-
-## Пример использования
-
-```javascript
-import { ErrorCenterHandler } from '@dxtmisha/functional-basic'
+#### `ErrorCenterHandlerItem`
+Связка группы и массива её функций.
+- `group?: ErrorCenterGroup` — целевая группа.
+- `handlers: ErrorCenterHandlerCallback[]` — список функций.
 
-const handlerManager = new ErrorCenterHandler()
+## Примеры
 
-// 1. Регистрация обработчика конкретной группы
-handlerManager.add('api', (cause) => {
-  console.log('[API Handler]', cause.message)
-})
+### Изолированный менеджер для модуля
+```typescript
+const uploadHandlers = new ErrorCenterHandler();
 
-// 2. Регистрация глобального обработчика
-handlerManager.add(undefined, (cause) => {
-  console.error('[Global Fallback]', cause.code)
-})
+uploadHandlers.add('upload', (cause) => {
+  if (cause.code === 'retry') {
+    restartUpload();
+  }
+});
 
-// 3. Вызов ошибки
-handlerManager.on({
-  group: 'api',
-  code: '500',
-  message: 'Внутренняя ошибка сервера'
-})
+uploadHandlers.on({ group: 'upload', code: 'retry' });
 ```

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

@@ -2,68 +2,72 @@ import {Meta} from '@storybook/addon-docs/blocks'
 
 <Meta title='@dxtmisha/vi/functional-basic/Classes/ErrorCenterHandler - Quản lý trình xử lý'/>
 
-# ErrorCenterHandler
+# Lớp ErrorCenterHandler
 
-Một lớp tiện ích cốt lõi để quản lý và kích hoạt các trình xử lý lỗi dựa trên các nhóm đã được định nghĩa. Nó cho phép các chiến lược phản hồi lỗi linh hoạt, chẳng hạn như hiển thị thông báo toàn cục cho các lỗi API trong khi thực hiện ghi nhật ký âm thầm cho các tác vụ nền.
+`ErrorCenterHandler` là trình quản lý để quản lý các hàm callback (trình xử lý). Nó cho phép bạn liên kết logic với các nhóm lỗi cụ thể và thực thi nó khi có sự kiện tương ứng xảy ra.
 
 ## Các tính năng chính
 
-- **Đăng ký trình xử lý** — Dễ dàng thêm nhiều hàm gọi lại cho các nhóm lỗi cụ thể.
-- **Lọc theo nhóm** — Nhắm mục tiêu các danh mục lỗi cụ thể (ví dụ: `api`, `auth`, `validation`).
-- **Dự phòng toàn cục** — Hỗ trợ trình xử lý cho nhóm `undefined` để bắt bất kỳ lỗi nào không có trình xử lý cụ thể.
-- **Thực thi tuần tự** — Kích hoạt tất cả các hàm gọi lại theo thứ tự chúng được thêm vào.
-- **Tích hợp ghi nhật ký** — Tự động xuất chi tiết lỗi ra console trình duyệt.
+- **Đăng ký trình xử lý** — thêm thuận tiện các hàm callback vào các nhóm cụ thể.
+- **Trình xử lý toàn cục** — hỗ trợ nhóm `undefined`, nhóm này bắt bất kỳ lỗi nào không có trình xử lý cụ thể.
+- **Thực thi tuần tự** — kích hoạt tất cả các hàm đã đăng ký theo thứ tự chúng được thêm vào.
+- **Ghi log tích hợp** — tự động xuất chi tiết lỗi ra console.
 
-## Các phương thức kiểm tra
+## Khởi tạo
 
-- `has(group: ErrorCenterGroup): boolean` — Kiểm tra xem có trình xử lý nào được đăng ký cho một nhóm không.
-- `get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined` — Truy xuất ánh xạ trình xử lý cho một nhóm.
+Để tạo một thực thể, sử dụng constructor `ErrorCenterHandler(handlers)`.
 
-## Cấu hình
+**Tham số:**
+- `handlers?: ErrorCenterHandlerList` — danh sách trình xử lý ban đầu.
 
-- `add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Thêm một hàm gọi lại cho một nhóm.
-- `addList(handlers: ErrorCenterHandlerList): this` — Đăng ký một loạt các trình xử lý.
+```typescript
+import { ErrorCenterHandler } from '@dxtmisha/functional-basic'
 
-## Các phương thức hành động
+const handlers = new ErrorCenterHandler([
+  {
+    group: 'api',
+    handlers: [(cause) => console.log('Lỗi API:', cause.code)]
+  }
+]);
+```
 
-### `on`
+## Các phương thức
 
-Kích hoạt tất cả các trình xử lý đã đăng ký cho nhóm của nguyên nhân lỗi được cung cấp. Nếu không tìm thấy trình xử lý cụ thể nào, nó sẽ quay về các trình xử lý được đăng ký cho nhóm `undefined` (nếu có). Luôn xuất chi tiết lỗi ra bảng điều khiển nội bộ.
+### Hành động
+- `on(cause: ErrorCenterCauseItem): this` — Kích hoạt chuỗi trình xử lý. Luôn xuất lỗi ra console qua `console.error`.
 
-**Tham số:**
-- `cause: ErrorCenterCauseItem` — Chi tiết lỗi để chuyển cho các trình xử lý.
+### Xác minh
+- `has(group: ErrorCenterGroup): boolean` — Kiểm tra xem có trình xử lý cho một nhóm không.
+- `get(group: ErrorCenterGroup): ErrorCenterHandlerItem | undefined` — Trả về danh sách các hàm cho một nhóm.
 
-**Trả về:** `this`
+### Cấu hình
+- `add(group: ErrorCenterGroup, handler: ErrorCenterHandlerCallback): this` — Thêm một hàm vào một nhóm.
+- `addList(handlers: ErrorCenterHandlerList): this` — Đăng ký hàng loạt các trình xử lý.
 
 ## Các kiểu dữ liệu
 
-### `ErrorCenterHandlerCallback`
+#### `ErrorCenterGroup`
+Tên nhóm (`string`) hoặc `undefined` để chặn toàn cục.
 
-Hàm cho các callback xử lý lỗi.
+#### `ErrorCenterHandlerCallback`
+Hàm callback: `(cause: ErrorCenterCauseItem) => void`.
 
-- `(cause: ErrorCenterCauseItem) => void` — Nhận đối tượng nguyên nhân lỗi đã được hợp nhất.
-
-## Ví dụ sử dụng
-
-```javascript
-import { ErrorCenterHandler } from '@dxtmisha/functional-basic'
+#### `ErrorCenterHandlerItem`
+Liên kết giữa một nhóm và một mảng các hàm của nó.
+- `group?: ErrorCenterGroup` — nhóm mục tiêu.
+- `handlers: ErrorCenterHandlerCallback[]` — danh sách các hàm.
 
-const handlerManager = new ErrorCenterHandler()
+## Ví dụ
 
-// 1. Đăng ký trình xử lý cho nhóm cụ thể
-handlerManager.add('api', (cause) => {
-  console.log('[API Handler]', cause.message)
-})
+### Trình quản lý cô lập cho một mô-đun
+```typescript
+const uploadHandlers = new ErrorCenterHandler();
 
-// 2. Đăng ký trình xử lý dự phòng toàn cục
-handlerManager.add(undefined, (cause) => {
-  console.error('[Global Fallback]', cause.code)
-})
+uploadHandlers.add('upload', (cause) => {
+  if (cause.code === 'retry') {
+    restartUpload();
+  }
+});
 
-// 3. Kích hoạt một lỗi
-handlerManager.on({
-  group: 'api',
-  code: '500',
-  message: 'Lỗi máy chủ nội bộ'
-})
+uploadHandlers.on({ group: 'upload', code: 'retry' });
 ```