@dxtmisha/wiki 0.39.1 → 0.39.2

package/src/media/functional/scripts/classes/DesignStructureRead/DesignStructureRead.en.mdx

@@ -0,0 +1,55 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/DesignStructureRead - Property Dependency Resolver'/>
+
+# DesignStructureRead Class
+
+The `DesignStructureRead` class is the primary parser for resolving dependencies and states between component properties. It transforms raw design system tokens into a structured list of properties, identifying which items should be exposed as public props and which represent internal interactive states or linked CSS class dependencies.
+
+## Key Features
+
+- **State Discovery** — Identifies property tokens defined as interactive states (e.g., `:hover`, `:active`) and builds their dependency chains.
+- **Link Class Resolution** — Detects and resolves references to external component classes to maintain BEM hierarchy.
+- **Value Compilation** — Aggregates all possible values for a property, including those derived from nested state structures, to generate accurate TypeScript unions.
+- **Prop Validation** — Filters and validates which property tokens are eligible for export as public component properties based on system rules.
+- **Independant Value Synthesis** — Automatically injects boolean flags for properties that lack explicit value tokens but require state tracking.
+
+## Initialization
+
+To initialize the property reader, provide the base component name. The class will automatically resolve the component's metadata via its parent abstraction and trigger the multi-stage parsing pipeline.
+
+**Parameters:**
+- `component: string` — The identifier of the component to analyze (e.g., `'input'`).
+
+```typescript
+import { DesignStructureRead } from '@dxtmisha/scripts'
+
+const reader = new DesignStructureRead('button')
+const structureList = reader.get()
+const states = reader.getStates()
+```
+
+## Methods
+
+### Information
+
+- `get(): DesignStructureList` — Returns the fully resolved linear list of component properties.
+- `getStates(): DesignStructureStateList` — Returns the hierarchical list of states and their associated property dependencies.
+
+## Operations
+
+### The Parsing Pipeline
+
+Upon construction, `DesignStructureRead` executes a series of transformations to build the final data model:
+1. **State Mapping (`makeState`)**: Recursively traverses the property tree to isolate tokens marked as `state` or `linkClass`.
+2. **Main Structure Initialization (`makeMain`)**: Creates the base entry for each identified prop, normalizing names and metadata.
+3. **Base Value Extraction (`makeValue`)**: Resolves the direct immediate values assigned to each property.
+4. **Value Expansion (`makeValueAll`)**: Aggregates values from all possible interactive states to ensure the property API covers every logical case.
+5. **Deduplication (`makeValueUnique`)**: Normalizes the value lists, removing duplicates and ensuring boolean fallbacks exist where necessary.
+
+### Handling Linked Classes
+
+Special logic is applied when a property references another component class (`linkClass`). The resolver:
+1. **Identifies the reference**: Locates the specific variable link in the global design metadata.
+2. **Naming Transformation**: Converts the reference into a standardized BEM class name (e.g., `theme-button--primary`).
+3. **Recursive Resolution**: Triggers a sub-parsing cycle for the linked component to ensure its properties and states are accounted for in the primary component's dependency tree.

package/src/media/functional/scripts/classes/DesignStructureRead/DesignStructureRead.ru.mdx

@@ -0,0 +1,55 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/scripts/Classes/DesignStructureRead - Разрешитель зависимостей свойств'/>
+
+# Класс DesignStructureRead
+
+Класс `DesignStructureRead` является основным парсером для разрешения зависимостей и состояний между свойствами компонентов. Он преобразует сырые токены дизайн-системы в структурированный список свойств, определяя, какие элементы должны быть представлены как публичные пропсы, а какие представляют собой внутренние интерактивные состояния или зависимости связанных CSS-классов.
+
+## Ключевые особенности
+
+- **Обнаружение состояний** — идентифицирует токены свойств, определенные как интерактивные состояния (например, `:hover`, `:active`), и выстраивает цепочки их зависимостей.
+- **Разрешение связанных классов** — обнаруживает и разрешает ссылки на внешние классы компонентов для сохранения иерархии BEM.
+- **Компиляция значений** — агрегирует все возможные значения для свойства, включая те, что получены из вложенных структур состояний, для генерации точных объединений TypeScript.
+- **Валидация пропсов** — фильтрует и проверяет, какие токены свойств имеют право на экспорт в качестве публичных свойств компонента на основе системных правил.
+- **Синтез независимых значений** — автоматически внедряет булевы флаги для свойств, у которых отсутствуют явные токены значений, но требуется отслеживание состояния.
+
+## Инициализация
+
+Для инициализации читателя свойств укажите базовое имя компонента. Класс автоматически разрешит метаданные компонента через свою родительскую абстракцию и запустит многоэтапный конвейер парсинга.
+
+**Параметры:**
+- `component: string` — идентификатор компонента для анализа (например, `'input'`).
+
+```typescript
+import { DesignStructureRead } from '@dxtmisha/scripts'
+
+const reader = new DesignStructureRead('button')
+const structureList = reader.get()
+const states = reader.getStates()
+```
+
+## Методы
+
+### Информация
+
+- `get(): DesignStructureList` — возвращает полностью разрешенный линейный список свойств компонента.
+- `getStates(): DesignStructureStateList` — возвращает иерархический список состояний и связанных с ними зависимостей свойств.
+
+## Операции
+
+### Конвейер парсинга
+
+При создании экземпляра `DesignStructureRead` выполняет серию трансформаций для построения финальной модели данных:
+1. **Маппинг состояний (`makeState`)**: рекурсивно обходит дерево свойств для изоляции токенов, помеченных как `state` или `linkClass`.
+2. **Инициализация основной структуры (`makeMain`)**: создает базовую запись для каждого идентифицированного пропса, нормализуя имена и метаданные.
+3. **Извлечение базовых значений (`makeValue`)**: разрешает прямые непосредственные значения, назначенные каждому свойству.
+4. **Расширение значений (`makeValueAll`)**: агрегирует значения из всех возможных интерактивных состояний, чтобы API свойств охватывало все логические случаи.
+5. **Дедупликация (`makeValueUnique`)**: нормализует списки значений, удаляя дубликаты и обеспечивая наличие булевых фолбэков там, где это необходимо.
+
+### Обработка связанных классов
+
+Специальная логика применяется, когда свойство ссылается на класс другого компонента (`linkClass`). Разрешитель:
+1. **Идентифицирует ссылку**: находит конкретную ссылку на переменную в глобальных метаданных дизайна.
+2. **Трансформация имени**: преобразует ссылку в стандартизированное имя класса BEM (например, `theme-button--primary`).
+3. **Рекурсивное разрешение**: запускает цикл подпарсинга для связанного компонента, чтобы гарантировать учет его свойств и состояний в дереве зависимостей основного компонента.

package/src/media/functional/scripts/classes/DesignStructureRead/DesignStructureRead.vi.mdx

@@ -0,0 +1,55 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/scripts/Classes/DesignStructureRead - Bộ phân giải phụ thuộc thuộc tính'/>
+
+# Lớp DesignStructureRead
+
+Lớp `DesignStructureRead` là trình phân tích cú pháp chính để phân giải các phụ thuộc và trạng thái giữa các thuộc tính của thành phần. Nó chuyển đổi các token hệ thống thiết kế thô thành một danh sách các thuộc tính có cấu trúc, xác định mục nào sẽ được hiển thị dưới dạng props công khai và mục nào đại diện cho các trạng thái tương tác nội bộ hoặc các phụ thuộc lớp CSS được liên kết.
+
+## Các tính năng chính
+
+- **Khám phá trạng thái** — Xác định các token thuộc tính được định nghĩa là trạng thái tương tác (ví dụ: `:hover`, `:active`) và xây dựng các chuỗi phụ thuộc của chúng.
+- **Phân giải lớp liên kết** — Phát hiện và phân giải các tham chiếu đến các lớp thành phần bên ngoài để duy trì phân cấp BEM.
+- **Biên soạn giá trị** — Tập hợp tất cả các giá trị có thể có cho một thuộc tính, bao gồm cả các giá trị bắt nguồn từ các cấu trúc trạng thái lồng nhau, để tạo ra các union TypeScript chính xác.
+- **Xác thực Prop** — Lọc và xác thực các token thuộc tính nào đủ điều kiện để xuất dưới dạng thuộc tính thành phần công khai dựa trên các quy tắc hệ thống.
+- **Tổng hợp giá trị độc lập** — Tự động chèn các cờ boolean cho các thuộc tính thiếu các token giá trị rõ ràng nhưng yêu cầu theo dõi trạng thái.
+
+## Khởi tạo
+
+Để khởi tạo trình đọc thuộc tính, hãy cung cấp tên thành phần cơ sở. Lớp sẽ tự động phân giải siêu dữ liệu của thành phần thông qua trừu tượng cha của nó và kích hoạt quy trình phân tích cú pháp nhiều giai đoạn.
+
+**Tham số:**
+- `component: string` — Mã định danh của thành phần cần phân tích (ví dụ: `'input'`).
+
+```typescript
+import { DesignStructureRead } from '@dxtmisha/scripts'
+
+const reader = new DesignStructureRead('button')
+const structureList = reader.get()
+const states = reader.getStates()
+```
+
+## Các phương thức
+
+### Thông tin
+
+- `get(): DesignStructureList` — Trả về danh sách tuyến tính đã được phân giải hoàn chỉnh của các thuộc tính thành phần.
+- `getStates(): DesignStructureStateList` — Trả về danh sách phân cấp các trạng thái và các phụ thuộc thuộc tính liên quan của chúng.
+
+## Các thao tác (Operations)
+
+### Quy trình phân tích cú pháp (The Parsing Pipeline)
+
+Khi được xây dựng, `DesignStructureRead` thực hiện một chuỗi các chuyển đổi để xây dựng mô hình dữ liệu cuối cùng:
+1. **Ánh xạ trạng thái (`makeState`)**: Duyệt đệ quy cây thuộc tính để tách biệt các token được đánh dấu là `state` hoặc `linkClass`.
+2. **Khởi tạo cấu trúc chính (`makeMain`)**: Tạo mục nhập cơ sở cho mỗi prop được xác định, chuẩn hóa tên và siêu dữ liệu.
+3. **Trích xuất giá trị cơ sở (`makeValue`)**: Phân giải các giá trị trực tiếp được gán cho mỗi thuộc tính.
+4. **Mở rộng giá trị (`makeValueAll`)**: Tập hợp các giá trị từ tất cả các trạng thái tương tác có thể để đảm bảo API thuộc tính bao quát mọi trường hợp logic.
+5. **Duy nhất hóa giá trị (`makeValueUnique`)**: Chuẩn hóa các danh sách giá trị, loại bỏ các mục trùng lặp và đảm bảo các fallback boolean tồn tại khi cần thiết.
+
+### Xử lý các lớp liên kết (Linked Classes)
+
+Logic đặc biệt được áp dụng khi một thuộc tính tham chiếu đến một lớp thành phần khác (`linkClass`). Bộ phân giải sẽ:
+1. **Xác định tham chiếu**: Tìm liên kết biến cụ thể trong siêu dữ liệu thiết kế toàn cục.
+2. **Chuyển đổi tên**: Chuyển đổi tham chiếu thành tên lớp BEM tiêu chuẩn hóa (ví dụ: `theme-button--primary`).
+3. **Phân giải đệ quy**: Kích hoạt một chu kỳ phân tích cú pháp phụ cho thành phần được liên kết để đảm bảo các thuộc tính và trạng thái của nó được tính đến trong cây phụ thuộc của thành phần chính.

package/src/media/functional/scripts/classes/DesignStructureStyles/DesignStructureStyles.en.mdx

@@ -0,0 +1,48 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/DesignStructureStyles - Component Style Compiler'/>
+
+# DesignStructureStyles Class
+
+The `DesignStructureStyles` class is responsible for converting a component's structural design tokens into a standardized array of CSS property strings. By leveraging the `StylesProperties` engine, it ensures that every component inherits its base visual identity directly from the design system's central theme configuration.
+
+## Key Features
+
+- **Token-to-CSS Transformation** — Automatically maps abstract design tokens to concrete CSS properties.
+- **BEM Selector Scoping** — Wraps generated styles in a component-level selector (`& { ... }`) to ensure style isolation.
+- **Hierarchical Inheritance** — Utilizes parent structural metadata to resolve nested property variables accurately.
+- **Standardized Formatting** — Applies consistent indentation and line breaks, ensuring generated style files remain readable.
+
+## Initialization
+
+To initialize the style compiler, provide the identifier of the component whose styles needs to be generated. The class will automatically load the relevant structural metadata.
+
+**Parameters:**
+- `component: string` — The identifier of the component (e.g., `'button'`).
+
+```typescript
+import { DesignStructureStyles } from '@dxtmisha/scripts'
+
+const compiler = new DesignStructureStyles('button')
+const stylesArray = compiler.get()
+```
+
+## Methods
+
+### Control
+
+- `make(): string[]` — Triggers the transformation process and returns the array of CSS property strings.
+
+## Operations
+
+### The Style Compilation Flow
+
+When the compiler is initialized, it follows a structured pipeline:
+1. **Metadata Loading**: It uses the parent `DesignStructureItemAbstract` logic to fetch the specific `PropertyItemsItem` associated with the component.
+2. **Contextual Selection**: The engine wraps all output properties within a self-referencing CSS selector (`& { ... }`) to maintain compatibility with CSS-in-JS and preprocessors.
+3. **Property Resolution**: It instantiates `StylesProperties`, passing the collected metadata. This sub-engine then traverses every token, resolving theme variables, units, and fallbacks.
+4. **Output Buffering**: The final list of properties is joined into a flat array of strings, ready for injection into a CSS file or a style tag.
+
+### Integration with Theme Engine
+
+This class acts as the bridge between raw design data and the final visual representation. By centralizing the style compilation logic, the system ensures that changes to the theme's core architecture (such as variable naming conventions or unit logic) are automatically propagated to all components during the next build cycle.

package/src/media/functional/scripts/classes/DesignStructureStyles/DesignStructureStyles.ru.mdx

@@ -0,0 +1,48 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/scripts/Classes/DesignStructureStyles - Компилятор стилей компонента'/>
+
+# Класс DesignStructureStyles
+
+Класс `DesignStructureStyles` отвечает за преобразование структурных дизайн-токенов компонента в стандартизированный массив строк свойств CSS. Используя движок `StylesProperties`, он гарантирует, что каждый компонент наследует свою базовую визуальную идентичность напрямую из центральной конфигурации темы дизайн-системы.
+
+## Ключевые особенности
+
+- **Трансформация токенов в CSS** — автоматически сопоставляет абстрактные токены дизайна с конкретными свойствами CSS.
+- **Изоляция селекторов (BEM)** — оборачивает сгенерированные стили в селектор уровня компонента (`& { ... }`) для обеспечения изоляции стилей.
+- **Иерархическое наследование** — использует родительские структурные метаданные для точного разрешения вложенных переменных свойств.
+- **Стандартизированное форматирование** — применяет согласованные отступы и переносы строк, гарантируя читаемость сгенерированных файлов стилей.
+
+## Инициализация
+
+Для инициализации компилятора стилей укажите идентификатор компонента, стили которого необходимо сгенерировать. Класс автоматически загрузит релевантные структурные метаданные.
+
+**Параметры:**
+- `component: string` — идентификатор компонента (например, `'button'`).
+
+```typescript
+import { DesignStructureStyles } from '@dxtmisha/scripts'
+
+const compiler = new DesignStructureStyles('button')
+const stylesArray = compiler.get()
+```
+
+## Методы
+
+### Управление
+
+- `make(): string[]` — запускает процесс трансформации и возвращает массив строк свойств CSS.
+
+## Операции
+
+### Рабочий процесс компиляции стилей
+
+При инициализации компилятор следует структурированному конвейеру:
+1. **Загрузка метаданных**: использует логику родительского `DesignStructureItemAbstract` для получения специфического `PropertyItemsItem`, связанного с компонентом.
+2. **Контекстный селектор**: движок оборачивает все выходные свойства в самоссылающийся CSS-селектор (`& { ... }`) для поддержания совместимости с CSS-in-JS и препроцессорами.
+3. **Разрешение свойств**: создается экземпляр `StylesProperties`, которому передаются собранные метаданные. Этот суб-движок обходит каждый токен, разрешая переменные темы, юниты и фолбэки.
+4. **Буферизация вывода**: финальный список свойств объединяется в плоский массив строк, готовый к внедрению в CSS-файл или тег стиля.
+
+### Интеграция с движком тем
+
+Этот класс выступает в качестве моста между необработанными данными дизайна и финальным визуальным представлением. Централизуя логику компиляции стилей, система гарантирует, что изменения в основной архитектуре темы (такие как соглашения об именовании переменных или логика единиц измерения) автоматически распространяются на все компоненты во время следующего цикла сборки.

package/src/media/functional/scripts/classes/DesignStructureStyles/DesignStructureStyles.vi.mdx

@@ -0,0 +1,48 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/scripts/Classes/DesignStructureStyles - Trình biên dịch kiểu dáng thành phần'/>
+
+# Lớp DesignStructureStyles
+
+Lớp `DesignStructureStyles` chịu trách nhiệm chuyển đổi các token thiết kế cấu trúc của thành phần thành một mảng chuẩn hóa các chuỗi thuộc tính CSS. Bằng cách tận dụng động cơ `StylesProperties`, nó đảm bảo rằng mọi thành phần đều kế thừa bản sắc hình ảnh cơ bản của mình trực tiếp từ cấu hình chủ đề trung tâm của hệ thống thiết kế.
+
+## Các tính năng chính
+
+- **Chuyển đổi Token sang CSS** — Tự động ánh xạ các token thiết kế trừu tượng sang các thuộc tính CSS cụ thể.
+- **Phạm vi bộ chọn BEM** — Gói các kiểu dáng được tạo trong một bộ chọn cấp thành phần (`& { ... }`) để đảm bảo cách ly kiểu dáng.
+- **Kế thừa phân cấp** — Sử dụng siêu dữ liệu cấu trúc của cha để phân giải chính xác các biến thuộc tính lồng nhau.
+- **Định dạng chuẩn hóa** — Áp dụng thụt lề và ngắt dòng nhất quán, đảm bảo các tệp kiểu dáng được tạo ra vẫn dễ đọc.
+
+## Khởi tạo
+
+Để khởi tạo trình biên dịch kiểu dáng, hãy cung cấp mã định danh của thành phần cần tạo kiểu dáng. Lớp sẽ tự động tải siêu dữ liệu cấu trúc liên quan.
+
+**Tham số:**
+- `component: string` — Mã định danh của thành phần (ví dụ: `'button'`).
+
+```typescript
+import { DesignStructureStyles } from '@dxtmisha/scripts'
+
+const compiler = new DesignStructureStyles('button')
+const stylesArray = compiler.get()
+```
+
+## Các phương thức
+
+### Điều khiển
+
+- `make(): string[]` — Kích hoạt quá trình chuyển đổi và trả về mảng các chuỗi thuộc tính CSS.
+
+## Các thao tác (Operations)
+
+### Quy trình biên dịch kiểu dáng
+
+Khi trình biên dịch được khởi tạo, nó tuân theo một quy trình có cấu trúc:
+1. **Tải siêu dữ liệu**: Nó sử dụng logic của lớp cha `DesignStructureItemAbstract` để lấy `PropertyItemsItem` cụ thể liên quan đến thành phần.
+2. **Lựa chọn ngữ cảnh**: Động cơ gói tất cả các thuộc tính đầu ra bên trong một bộ chọn CSS tự tham chiếu (`& { ... }`) để duy trì tính tương thích với CSS-in-JS và các trình tiền xử lý.
+3. **Phân giải thuộc tính**: Nó khởi tạo `StylesProperties`, chuyển siêu dữ liệu đã thu thập. Động cơ phụ này sau đó duyệt qua mọi token, phân giải các biến chủ đề, đơn vị và các phương án dự phòng (fallbacks).
+4. **Đệm đầu ra**: Danh sách các thuộc tính cuối cùng được kết hợp thành một mảng phẳng các chuỗi, sẵn sàng để tiêm vào tệp CSS hoặc thẻ style.
+
+### Tích hợp với Động cơ Chủ đề (Theme Engine)
+
+Lớp này đóng vai trò là cầu nối giữa dữ liệu thiết kế thô và biểu diễn hình ảnh cuối cùng. Bằng cách tập trung logic biên dịch kiểu dáng, hệ thống đảm bảo rằng các thay đổi đối với kiến trúc cốt lõi của chủ đề (chẳng hạn như quy ước đặt tên biến hoặc logic đơn vị) sẽ tự động được truyền bá đến tất cả các thành phần trong chu kỳ xây dựng tiếp theo.

package/src/media/functional/scripts/classes/DesignTypes/DesignTypes.en.mdx

@@ -0,0 +1,50 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/DesignTypes - AI Type Generator'/>
+
+# DesignTypes Class
+
+The `DesignTypes` class is a specialized utility designed to bridge the gap between complex codebase type definitions and AI coding assistants. It automates the extraction, sanitation, and compression of TypeScript declaration files (`.d.ts`), using AI to generate a hyper-minimalized version of the project's type system that provides maximum context with minimum token usage.
+
+## Key Features
+
+- **Automated Discovery** — Recursively scans distribution directories to find relevant type declaration files.
+- **Intelligent Filtering** — Automatically excludes internal constructor props and non-essential logic types while preserving public APIs.
+- **AI-Driven Compression** — Uses LLM prompts to strip unnecessary metadata (imports, Russian comments, empty lines) and consolidate definitions.
+- **Unified Output** — Combines multiple fragmented declaration files into a single, cohesive type library.
+- **Context Optimization** — Prioritizes interfaces, enums, and type aliases that are most critical for AI understanding.
+
+## Initialization
+
+Initialize the generator by specifying the source directory where the compiled declaration files are located.
+
+**Parameters:**
+- `dir: string` — The path to the input directory (default is `'dist'`).
+
+```typescript
+import { DesignTypes } from '@dxtmisha/scripts'
+
+const generator = new DesignTypes('packages/core/dist')
+generator.make()
+```
+
+## Methods
+
+### Control
+
+- `make(): void` — Starts the full generation pipeline: discovery, combination, AI processing, and storage.
+
+## Operations
+
+### The Type Generation Pipeline
+
+When `make()` is executed, the class coordinates a multi-stage workflow:
+1. **File Filtering (`getListByFilter`)**: The engine scans the directory for `.d.ts` files, filtering out internal implementation details like `props.d.ts` or `types.d.ts` within constructor folders.
+2. **Content Validation (`isContent`)**: It verifies that each file actually contains meaningful type definitions (interfaces, types, or enums) before processing.
+3. **Consolidation (`toOneFile`)**: All identified file contents are merged into a single large string, tagged with their original file paths for context.
+4. **AI Transformation (`toAiEdit`)**: The merged content is sent to an AI assistant with specific instructions to strip boilerplate, remove non-English comments, and minimize syntax.
+5. **Persistence (`save`)**: The final, high-density type library is saved to the configured output path (usually specified in `UI_FILE_AI_TYPES`).
+
+### Use Case: AI Context Injection
+
+The primary goal of this class is to create a "knowledge artifact" that can be injected into the system prompt of LLMs working on the project. By providing a clean, compressed overview of all available types and interfaces, the AI can write type-safe code and understand component architectures with significantly higher accuracy and lower cost.

package/src/media/functional/scripts/classes/DesignTypes/DesignTypes.ru.mdx

@@ -0,0 +1,50 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/scripts/Classes/DesignTypes - Генератор типов для ИИ'/>
+
+# Класс DesignTypes
+
+Класс `DesignTypes` — это специализированная утилита, предназначенная для сокращения разрыва между сложными определениями типов в коде и ИИ-помощниками по кодированию. Она автоматизирует извлечение, очистку и сжатие файлов деклараций TypeScript (`.d.ts`), используя ИИ для создания гипер-минималистичной версии системы типов проекта, которая обеспечивает максимальный контекст при минимальном потреблении токенов.
+
+## Ключевые особенности
+
+- **Автоматическое обнаружение** — рекурсивно сканирует директории сборки для поиска релевантных файлов деклараций типов.
+- **Интеллектуальная фильтрация** — автоматически исключает внутренние пропсы конструкторов и второстепенные типы логики, сохраняя публичные API.
+- **Сжатие на базе ИИ** — использует промпты LLM для удаления ненужных метаданных (импортов, комментариев, пустых строк) и консолидации определений.
+- **Единый вывод** — объединяет несколько фрагментированных файлов деклараций в одну связную библиотеку типов.
+- **Оптимизация контекста** — приоритизирует интерфейсы, перечисления и алиасы типов, наиболее важные для понимания ИИ.
+
+## Инициализация
+
+Инициализируйте генератор, указав исходную директорию, где расположены скомпилированные файлы деклараций.
+
+**Параметры:**
+- `dir: string` — путь к входной директории (по умолчанию `'dist'`).
+
+```typescript
+import { DesignTypes } from '@dxtmisha/scripts'
+
+const generator = new DesignTypes('packages/core/dist')
+generator.make()
+```
+
+## Методы
+
+### Управление
+
+- `make(): void` — запускает полный конвейер генерации: обнаружение, объединение, обработку ИИ и сохранение.
+
+## Операции
+
+### Конвейер генерации типов
+
+При выполнении `make()` класс координирует многоэтапный рабочий процесс:
+1. **Фильтрация файлов (`getListByFilter`)**: движок сканирует директорию на наличие файлов `.d.ts`, отфильтровывая детали внутренней реализации, такие как `props.d.ts` или `types.d.ts` внутри папок конструкторов.
+2. **Валидация контента (`isContent`)**: проверяет, что каждый файл действительно содержит значимые определения типов (интерфейсы, типы или перечисления) перед обработкой.
+3. **Консолидация (`toOneFile`)**: содержимое всех идентифицированных файлов объединяется в одну большую строку, помеченную путями к оригинальным файлам для контекста.
+4. **Трансформация ИИ (`toAiEdit`)**: объединенный контент отправляется ИИ-помощнику со специфическими инструкциями по удалению шаблонного кода, неанглийских комментариев и минимизации синтаксиса.
+5. **Сохранение (`save`)**: финальная библиотека типов высокой плотности сохраняется по настроенному пути вывода (обычно указанному в `UI_FILE_AI_TYPES`).
+
+### Кейс: Внедрение контекста для ИИ
+
+Основная цель этого класса — создание «артефакта знаний», который может быть внедрен в системный промпт LLM, работающих над проектом. Предоставляя чистый, сжатый обзор всех доступных типов и интерфейсов, ИИ может писать типобезопасный код и понимать архитектуру компонентов с значительно более высокой точностью и меньшими затратами.

package/src/media/functional/scripts/classes/DesignTypes/DesignTypes.vi.mdx

@@ -0,0 +1,50 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/scripts/Classes/DesignTypes - Trình tạo kiểu AI'/>
+
+# Lớp DesignTypes
+
+Lớp `DesignTypes` là một tiện ích chuyên dụng được thiết kế để thu hẹp khoảng cách giữa các định nghĩa kiểu (type definitions) phức tạp trong mã nguồn và các trợ lý lập trình AI. Nó tự động hóa việc trích xuất, làm sạch và nén các tệp khai báo TypeScript (`.d.ts`), sử dụng AI để tạo ra phiên bản cực kỳ tối giản của hệ thống kiểu trong dự án, cung cấp ngữ cảnh tối đa với mức tiêu thụ token tối thiểu.
+
+## Các tính năng chính
+
+- **Khám phá tự động** — Quét đệ quy các thư mục phân phối để tìm các tệp khai báo kiểu có liên quan.
+- **Lọc thông minh** — Tự động loại trừ các props constructor nội bộ và các kiểu logic không thiết yếu trong khi vẫn giữ lại các API công khai.
+- **Nén dựa trên AI** — Sử dụng các gợi ý LLM để loại bỏ siêu dữ liệu không cần thiết (imports, chú thích tiếng Nga, dòng trống) и hợp nhất các định nghĩa.
+- **Đầu ra thống nhất** — Kết hợp nhiều tệp khai báo rời rạc thành một thư viện kiểu gắn kết duy nhất.
+- **Tối ưu hóa ngữ cảnh** — Ưu tiên các interfaces, enums và type aliases quan trọng nhất đối với sự hiểu biết của AI.
+
+## Khởi tạo
+
+Khởi tạo trình tạo bằng cách chỉ định thư mục nguồn nơi đặt các tệp khai báo đã biên dịch.
+
+**Tham số:**
+- `dir: string` — Đường dẫn đến thư mục đầu vào (mặc định là `'dist'`).
+
+```typescript
+import { DesignTypes } from '@dxtmisha/scripts'
+
+const generator = new DesignTypes('packages/core/dist')
+generator.make()
+```
+
+## Các phương thức
+
+### Điều khiển
+
+- `make(): void` — Bắt đầu toàn bộ quy trình tạo: khám phá, kết hợp, xử lý AI và lưu trữ.
+
+## Các thao tác (Operations)
+
+### Quy trình tạo kiểu (Type Generation Pipeline)
+
+Khi `make()` được thực thi, lớp sẽ điều phối một quy trình làm việc gồm nhiều giai đoạn:
+1. **Lọc tệp (`getListByFilter`)**: Động cơ quét thư mục để tìm các tệp `.d.ts`, lọc ra các chi tiết triển khai nội bộ như `props.d.ts` hoặc `types.d.ts` bên trong các thư mục constructor.
+2. **Xác thực nội dung (`isContent`)**: Nó xác minh rằng mỗi tệp thực sự chứa các định nghĩa kiểu có ý nghĩa (interfaces, types hoặc enums) trước khi xử lý.
+3. **Hợp nhất (`toOneFile`)**: Tất cả nội dung tệp được xác định sẽ được hợp nhất thành một chuỗi lớn duy nhất, được gắn thẻ với đường dẫn tệp gốc để cung cấp ngữ cảnh.
+4. **Chuyển đổi AI (`toAiEdit`)**: Nội dung đã hợp nhất được gửi đến trợ lý AI với các hướng dẫn cụ thể để loại bỏ mã mẫu (boilerplate), xóa các chú thích không phải tiếng Anh và tối thiểu hóa cú pháp.
+5. **Lưu trữ (`save`)**: Thư viện kiểu mật độ cao cuối cùng được lưu vào đường dẫn đầu ra đã định cấu hình (thường được chỉ định trong `UI_FILE_AI_TYPES`).
+
+### Trường hợp sử dụng: Tiêm ngữ cảnh AI
+
+Mục tiêu chính của lớp này là tạo ra một "kiến thức nhân tạo" có thể được tiêm vào hệ thống prompt của các LLM đang làm việc trong dự án. Bằng cách cung cấp một cái nhìn tổng quan sạch sẽ, cô đọng về tất cả các kiểu và interface có sẵn, AI có thể viết mã an toàn về kiểu (type-safe) và hiểu kiến trúc thành phần với độ chính xác cao hơn đáng kể và chi phí thấp hơn.

package/src/media/functional/scripts/classes/DesignTypescript/DesignTypescript.en.mdx

@@ -0,0 +1,55 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/DesignTypescript - Type Metadata Analyzer'/>
+
+# DesignTypescript Class
+
+The `DesignTypescript` class provides a high-level wrapper around the TypeScript Compiler API, allowing programmatic analysis of source code metadata. It specializes in extracting structured information from interfaces and type aliases, making it an essential tool for generating documentation, validation schemas, or optimized type definitions for AI assistants.
+
+## Key Features
+
+- **Compiler API Integration** — Seamlessly interacts with TypeScript's internal program and type checker.
+- **Deep Type Extraction** — Resolves complex property types, literal unions, and optionality.
+- **Documentation Retrieval** — Automatically extracts JSDoc comments to preserve developer-written context.
+- **AST-Aware Parsing** — Navigates the Abstract Syntax Tree (AST) to reliably identify interfaces and type declarations.
+- **Literal Value Discovery** — Intelligently broadens literal unions into usable string/number options.
+
+## Initialization
+
+Initialize the analyzer by providing the path to a TypeScript source file. You can also specify custom compiler options to match your project's environment.
+
+**Parameters:**
+- `path: string` — The absolute or relative path to the `.ts` file (default is `''`).
+- `options: ts.CompilerOptions` — Optional TypeScript compiler configuration (default is `{}`).
+
+```typescript
+import { DesignTypescript } from '@dxtmisha/scripts'
+
+const analyzer = new DesignTypescript('src/types/component.ts')
+const types = analyzer.getTypes()
+```
+
+## Methods
+
+### Data Acquisition
+
+- `getTypes(): DesignTypescriptList` — Scans the source file and returns an array of all detected type and interface metadata.
+- `getType(name: string): DesignTypescriptItem | undefined` — Retrieves metadata for a specific type or interface by its name.
+
+## Operations
+
+### The Metadata Analysis Workflow
+
+When analyzing a file, `DesignTypescript` performs the following steps:
+1. **Program Creation**: It initializes a TypeScript Program and Type Checker for the specified file.
+2. **Node Traversal**: It visits every node in the AST, specifically seeking `TypeAliasDeclaration` and `InterfaceDeclaration` nodes.
+3. **Property Resolution**: For each identified type, it queries the Type Checker to retrieve its properties (even those inherited).
+4. **Information Synthesis**: For every property, it builds a metadata object containing:
+    - **Name**: The property identifier.
+    - **Type**: A clean string representation of the type (e.g., `'string | number'`).
+    - **Options**: If the property is a literal union, it extracts the actual values.
+    - **Description**: The associated JSDoc comment.
+
+### Role in the Toolchain
+
+This class is frequently used by other generators (like `DesignTypes` or `DesignCommand`) to bridge the gap between static code and dynamic logic. By providing a clean API to the complex TypeScript Compiler, it allows the design system to remain "type-aware" across all its automated processes.

package/src/media/functional/scripts/classes/DesignTypescript/DesignTypescript.ru.mdx

@@ -0,0 +1,55 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/scripts/Classes/DesignTypescript - Анализатор метаданных типов'/>
+
+# Класс DesignTypescript
+
+Класс `DesignTypescript` предоставляет высокоуровневую обертку вокруг TypeScript Compiler API, позволяя программно анализировать метаданные исходного кода. Он специализируется на извлечении структурированной информации из интерфейсов и псевдонимов типов, что делает его важным инструментом для генерации документации, схем валидации или оптимизированных определений типов для ИИ-помощников.
+
+## Ключевые особенности
+
+- **Интеграция с Compiler API** — бесшовное взаимодействие с внутренней программой и средством проверки типов TypeScript.
+- **Глубокое извлечение типов** — разрешает сложные типы свойств, литеральные объединения и опциональность.
+- **Получение документации** — автоматически извлекает комментарии JSDoc для сохранения контекста, написанного разработчиком.
+- **AST-парсинг** — перемещается по абстрактному синтаксическому дереву (AST) для надежной идентификации интерфейсов и объявлений типов.
+- **Обнаружение литеральных значений** — интеллектуально расширяет литеральные объединения в используемые строковые или числовые опции.
+
+## Инициализация
+
+Инициализируйте анализатор, указав путь к исходному файлу TypeScript. Вы также можете указать пользовательские опции компилятора в соответствии с окружением вашего проекта.
+
+**Параметры:**
+- `path: string` — абсолютный или относительный путь к файлу `.ts` (по умолчанию `''`).
+- `options: ts.CompilerOptions` — необязательная конфигурация компилятора TypeScript (по умолчанию `{}`).
+
+```typescript
+import { DesignTypescript } from '@dxtmisha/scripts'
+
+const analyzer = new DesignTypescript('src/types/component.ts')
+const types = analyzer.getTypes()
+```
+
+## Методы
+
+### Получение данных
+
+- `getTypes(): DesignTypescriptList` — сканирует исходный файл и возвращает массив метаданных всех обнаруженных типов и интерфейсов.
+- `getType(name: string): DesignTypescriptItem | undefined` — получает метаданные для конкретного типа или интерфейса по его имени.
+
+## Операции
+
+### Рабочий процесс анализа метаданных
+
+При анализе файла `DesignTypescript` выполняет следующие шаги:
+1. **Создание программы**: инициализирует программу TypeScript и Type Checker для указанного файла.
+2. **Обход узлов**: посещает каждый узел в AST, специально разыскивая узлы `TypeAliasDeclaration` и `InterfaceDeclaration`.
+3. **Разрешение свойств**: для каждого идентифицированного типа опрашивает Type Checker для получения его свойств (включая наследуемые).
+4. **Синтез информации**: для каждого свойства строит объект метаданных, содержащий:
+    - **Name**: идентификатор свойства.
+    - **Type**: чистое строковое представление типа (например, `'string | number'`).
+    - **Options**: если свойство является литеральным объединением, извлекает фактические значения.
+    - **Description**: связанный комментарий JSDoc.
+
+### Роль в инструментарии
+
+Этот класс часто используется другими генераторами (такими как `DesignTypes` или `DesignCommand`) для преодоления разрыва между статическим кодом и динамической логикой. Предоставляя чистый API к сложному компилятору TypeScript, он позволяет дизайн-системе оставаться «знающей типы» во всех её автоматизированных процессах.