@dxtmisha/wiki 0.39.1 → 0.39.2

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

@@ -0,0 +1,73 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/PropertiesToAbstract - Base Transformation Class'/>
+
+# PropertiesToAbstract Class
+
+The `PropertiesToAbstract` class serves as the foundation for all property (token) transformation processes within the system. It defines a common transformation lifecycle, ranging from data initialization to cache persistence.
+
+## Key Features
+
+- **Lifecycle Standardization** — ensures a consistent execution order (`init` -> `write`) across all subclasses.
+- **PropertiesItems Integration** — provide centralized management of property items.
+- **Cache Management** — automates the process of writing intermediate results to a specified file.
+
+## Initialization
+
+As an abstract class, it cannot be instantiated directly. It is intended to be extended by concrete transformation classes (e.g., for SCSS or JSON generation).
+
+**Example subclass implementation:**
+
+```typescript
+import { PropertiesToAbstract, PropertiesItems } from '@dxtmisha/scripts'
+
+class MyPropertiesTransformer extends PropertiesToAbstract {
+  protected readonly FILE_CACHE = 'my-cache-file.json'
+
+  protected init(): void {
+    // Initialization and transformation logic
+    console.log('Transforming data...')
+  }
+}
+```
+
+## Methods
+
+### `to`
+Executes the full transformation cycle. This method is the public entry point and ensures a strict sequence of actions: data initialization followed by data writing.
+
+```typescript
+const transformer = new MyPropertiesTransformer(items);
+transformer.to(); // Starts the process
+```
+
+### `init` (abstract)
+An abstract protected method that must be implemented by subclasses. The primary data processing logic should be centered within this method.
+
+### `write` (protected)
+Writes the current state of property items (`PropertiesItems`) to a file defined by the `FILE_CACHE` path.
+
+**Returns:** `void`
+
+## Properties
+
+### `FILE_CACHE` (abstract)
+An abstract property defining the file path where the transformation results will be saved. It must be overridden in every concrete subclass.
+
+## Examples
+
+### Creating a Custom Transformer
+```typescript
+import { PropertiesToAbstract, PropertiesItems } from '@dxtmisha/scripts'
+
+export class PropertiesToCustom extends PropertiesToAbstract {
+  protected readonly FILE_CACHE = 'custom-tokens.json'
+
+  protected init(): void {
+    // Example of data modification before writing
+    forEach(this.items, (item) => {
+      item.myData = 'processed'
+    })
+  }
+}
+```

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

@@ -0,0 +1,73 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/scripts/Classes/PropertiesToAbstract - Базовый класс трансформации'/>
+
+# Абстрактный класс PropertiesToAbstract
+
+Класс `PropertiesToAbstract` служит фундаментом для всех процессов преобразования свойств (токенов) в системе. Он определяет общий жизненный цикл трансформации: от инициализации данных до их сохранения в кэш.
+
+## Ключевые особенности
+
+- **Стандартизация жизненного цикла** — гарантирует единый порядок выполнения операций (`init` -> `write`) во всех наследниках.
+- **Интеграция с PropertiesItems** — обеспечивает централизованное управление элементами свойств.
+- **Управление кэшем** — автоматизирует процесс записи промежуточных результатов в указанный файл.
+
+## Инициализация
+
+Поскольку класс является абстрактным, он не может быть создан напрямую. Он предназначен для расширения конкретными классами трансформации (например, для генерации SCSS или JSON).
+
+**Пример реализации наследника:**
+
+```typescript
+import { PropertiesToAbstract, PropertiesItems } from '@dxtmisha/scripts'
+
+class MyPropertiesTransformer extends PropertiesToAbstract {
+  protected readonly FILE_CACHE = 'my-cache-file.json'
+
+  protected init(): void {
+    // Логика инициализации и трансформации
+    console.log('Transforming data...')
+  }
+}
+```
+
+## Методы
+
+### `to`
+Запускает полный цикл трансформации. Этот метод является публичной точкой входа и обеспечивает строгую последовательность действий: сначала инициализация данных, затем их запись.
+
+```typescript
+const transformer = new MyPropertiesTransformer(items);
+transformer.to(); // Запуск процесса
+```
+
+### `init` (abstract)
+Абстрактный защищенный метод, который должен быть реализован в классах-наследниках. В этом методе должна быть сосредоточена основная логика обработки данных.
+
+### `write` (protected)
+Записывает текущее состояние элементов свойств (`PropertiesItems`) в файл, путь к которому определен в `FILE_CACHE`.
+
+**Возвращает:** `void`
+
+## Свойства
+
+### `FILE_CACHE` (abstract)
+Абстрактное свойство, определяющее путь к файлу, в который будут сохранены результаты трансформации. Должно быть переопределено в каждом конкретном классе-наследнике.
+
+## Примеры
+
+### Создание кастомного трансформера
+```typescript
+import { PropertiesToAbstract, PropertiesItems } from '@dxtmisha/scripts'
+
+export class PropertiesToCustom extends PropertiesToAbstract {
+  protected readonly FILE_CACHE = 'custom-tokens.json'
+
+  protected init(): void {
+    // Пример модификации данных перед записью
+    forEach(this.items, (item) => {
+      item.myData = 'processed'
+    })
+  }
+}
+```

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

@@ -0,0 +1,73 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/scripts/Classes/PropertiesToAbstract - Lớp chuyển đổi cơ sở'/>
+
+# Lớp PropertiesToAbstract
+
+Lớp `PropertiesToAbstract` đóng vai trò là nền tảng cho tất cả các quy trình chuyển đổi thuộc tính (token) trong hệ thống. Nó xác định một vòng đời chuyển đổi chung, từ khởi tạo dữ liệu đến duy trì bộ nhớ đệm (cache).
+
+## Các tính năng chính
+
+- **Tiêu chuẩn hóa vòng đời** — đảm bảo thứ tự thực hiện nhất quán (`init` -> `write`) trên tất cả các lớp con.
+- **Tích hợp PropertiesItems** — cung cấp khả năng quản lý tập trung các mục thuộc tính.
+- **Quản lý bộ nhớ đệm** — tự động hóa quá trình ghi các kết quả trung gian vào một tệp được chỉ định.
+
+## Khởi tạo
+
+Vì đây là một lớp trừu tượng (abstract class), nó không thể được khởi tạo trực tiếp. Nó được thiết kế để được kế thừa bởi các lớp chuyển đổi cụ thể (ví dụ: để tạo SCSS hoặc JSON).
+
+**Ví dụ về triển khai lớp con:**
+
+```typescript
+import { PropertiesToAbstract, PropertiesItems } from '@dxtmisha/scripts'
+
+class MyPropertiesTransformer extends PropertiesToAbstract {
+  protected readonly FILE_CACHE = 'my-cache-file.json'
+
+  protected init(): void {
+    // Logic khởi tạo và chuyển đổi
+    console.log('Transforming data...')
+  }
+}
+```
+
+## Các phương thức
+
+### `to`
+Thực hiện chu kỳ chuyển đổi đầy đủ. Phương thức này là điểm vào công khai (public entry point) và đảm bảo một trình tự hành động nghiêm ngặt: khởi tạo dữ liệu và sau đó là ghi dữ liệu.
+
+```typescript
+const transformer = new MyPropertiesTransformer(items);
+transformer.to(); // Bắt đầu quy trình
+```
+
+### `init` (trừu tượng)
+Một phương thức trừu tượng được bảo vệ (protected) phải được triển khai bởi các lớp con. Logic xử lý dữ liệu chính nên được tập trung trong phương thức này.
+
+### `write` (được bảo vệ)
+Ghi trạng thái hiện tại của các mục thuộc tính (`PropertiesItems`) vào một tệp được xác định bởi đường dẫn `FILE_CACHE`.
+
+**Trả về:** `void`
+
+## Các thuộc tính
+
+### `FILE_CACHE` (trừu tượng)
+Một thuộc tính trừu tượng xác định đường dẫn tệp nơi lưu kết quả chuyển đổi. Nó phải được ghi đè (overridden) trong mọi lớp con cụ thể.
+
+## Ví dụ (Examples)
+
+### Tạo một bộ chuyển đổi tùy chỉnh (Custom Transformer)
+```typescript
+import { PropertiesToAbstract, PropertiesItems } from '@dxtmisha/scripts'
+
+export class PropertiesToCustom extends PropertiesToAbstract {
+  protected readonly FILE_CACHE = 'custom-tokens.json'
+
+  protected init(): void {
+    // Ví dụ về sửa đổi dữ liệu trước khi ghi
+    forEach(this.items, (item) => {
+      item.myData = 'processed'
+    })
+  }
+}
+```

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

@@ -0,0 +1,112 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/PropertiesTool - Property Utilities'/>
+
+# PropertiesTool Class
+
+The `PropertiesTool` class provides a set of static utilities for handling component naming, path resolution, and reading design system configuration files. It serves as an auxiliary tool for other classes, ensuring consistency in naming conventions and providing efficient access to file resources.
+
+## Key Features
+
+- **Naming Standardization** — generates consistent component and CSS class names (camelCase).
+- **Constructor Logic** — includes functionality for identifying and loading base constructor properties.
+- **Cache Integration** — provides efficient reading of property files through a caching system.
+- **Flexible Configuration** — retrieves active design identifiers directly from environment settings.
+
+## Initialization
+
+The class provides only static methods, so creating an instance via `new` is not required.
+
+```typescript
+import { PropertiesTool } from '@dxtmisha/scripts'
+
+// Direct call to static methods
+const isConst = PropertiesTool.isConstructor('basic')
+```
+
+## Methods
+
+### `isConstructor`
+Checks if the provided design name matches the system's constructor key. This is essential for separating base meta-properties from specific theme-related properties.
+
+**Parameters:**
+- `design: string` — the design name to verify.
+
+**Returns:** `boolean` — `true` if the design is a constructor.
+
+```typescript
+const result = PropertiesTool.isConstructor('dxt.constructor');
+// Result: true
+```
+
+### `getDesigns`
+Returns a list of design identifiers available in the current environment. This list includes the system constructor and the design specified in the project's primary configuration.
+
+**Returns:** `string[]` — an array of design names.
+
+```typescript
+const list = PropertiesTool.getDesigns();
+// Result: ['dxt.constructor', 'my-project-design']
+```
+
+### `getComponentName`
+Generates a normalized component name string by combining the design name and the component name. The component name is automatically converted to `camelCase`.
+
+**Parameters:**
+- `design: string` — the design name.
+- `component: string` (optional) — the component name.
+
+**Returns:** `string` — the generated name (e.g., `designName-componentName`).
+
+```typescript
+const name = PropertiesTool.getComponentName('basic', 'button-primary');
+// Result: "basic-buttonPrimary"
+```
+
+### `getClassName`
+Similar to `getComponentName`, but returns a string formatted as a CSS class selector (starting with a dot).
+
+**Parameters:**
+- `design: string` — the design name.
+- `component: string` (optional) — the component name.
+
+**Returns:** `string` — a CSS class string.
+
+```typescript
+const selector = PropertiesTool.getClassName('basic', 'button');
+// Result: ".basic-button"
+```
+
+### `readFile`
+Reads and returns a list of properties (tokens) from the file system. For the constructor, it returns a copy of base properties from `properties.json`; for others, it reads the property file via the system cache.
+
+**Parameters:**
+- `design: string` — the design name.
+- `path: string[] | undefined` — the directory path containing the file.
+
+**Returns:** `PropertyList | undefined` — a property object or `undefined` if the path is not provided.
+
+```typescript
+const data = PropertiesTool.readFile('basic', ['src', 'theme', 'settings', 'button']);
+```
+
+## Operations
+
+### The Name Resolution Mechanism
+
+1. **Case Transformation**: All input component names undergo `toCamelCase` before being merged.
+2. **Prefixing**: Public methods always prepend the design name, preventing style collisions when using multiple themes simultaneously.
+3. **Safe Reading**: When reading files via `readFile` for the constructor, deep copying (`copyObject`) is used to prevent accidental mutation of global base settings by other tools.
+
+## Examples
+
+### Generating a CSS Class for a Dynamic Component
+```typescript
+import { PropertiesTool } from '@dxtmisha/scripts'
+
+const design = 'basic'
+const component = 'input-field'
+
+const className = PropertiesTool.getClassName(design, component)
+// Result: .basic-inputField
+```

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

@@ -0,0 +1,112 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/scripts/Classes/PropertiesTool - Утилиты свойств'/>
+
+# Класс PropertiesTool
+
+Класс `PropertiesTool` предоставляет набор статических утилит для работы с именованием компонентов, путями и чтением файлов конфигурации дизайн-системы. Он служит вспомогательным инструментом для других классов, обеспечивая единообразие в формировании имен и доступ к файловым ресурсам.
+
+## Ключевые особенности
+
+- **Стандартизация имен** — формирует единообразные названия компонентов и CSS-классов (camelCase).
+- **Работа с конструктором** — содержит логику для идентификации и загрузки базовых свойств конструктора.
+- **Интеграция с кэшем** — обеспечивает эффективное чтение файлов свойств через систему кэширования.
+- **Гибкая конфигурация** — получает список активных дизайнов напрямую из настроек окружения.
+
+## Инициализация
+
+Класс предоставляет только статические методы, поэтому создание экземпляра через `new` не требуется.
+
+```typescript
+import { PropertiesTool } from '@dxtmisha/scripts'
+
+// Прямой вызов статических методов
+const isConst = PropertiesTool.isConstructor('basic')
+```
+
+## Методы
+
+### `isConstructor`
+Проверяет, соответствует ли переданное имя дизайна ключу конструктора системы. Это необходимо для отделения базовых мета-свойств от свойств конкретных тем оформления.
+
+**Параметры:**
+- `design: string` — проверяемое название дизайна.
+
+**Возвращает:** `boolean` — `true`, если дизайн является конструктором.
+
+```typescript
+const result = PropertiesTool.isConstructor('dxt.constructor');
+// Результат: true
+```
+
+### `getDesigns`
+Возвращает список идентификаторов дизайнов, доступных в текущей среде. Список включает как системный конструктор, так и дизайн, указанный в основных настройках проекта.
+
+**Возвращает:** `string[]` — массив названий дизайнов.
+
+```typescript
+const list = PropertiesTool.getDesigns();
+// Результат: ['dxt.constructor', 'my-project-design']
+```
+
+### `getComponentName`
+Формирует нормализованную строку имени компонента, объединяя название дизайна и имя самого компонента. Имя компонента автоматически преобразуется в `camelCase`.
+
+**Параметры:**
+- `design: string` — название дизайна.
+- `component: string` (опционально) — название компонента.
+
+**Возвращает:** `string` — сформированное имя (например, `designName-componentName`).
+
+```typescript
+const name = PropertiesTool.getComponentName('basic', 'button-primary');
+// Результат: "basic-buttonPrimary"
+```
+
+### `getClassName`
+Аналогичен `getComponentName`, но возвращает строку в формате CSS-селектора класса (с точкой в начале).
+
+**Параметры:**
+- `design: string` — название дизайна.
+- `component: string` (опционально) — название компонента.
+
+**Возвращает:** `string` — строка CSS-класса.
+
+```typescript
+const selector = PropertiesTool.getClassName('basic', 'button');
+// Результат: ".basic-button"
+```
+
+### `readFile`
+Считывает и возвращает список свойств (tokens) из файловой системы. Для конструктора возвращает копию базовых свойств из `properties.json`, для остальных — считывает файл свойств через системный кэш.
+
+**Параметры:**
+- `design: string` — название дизайна.
+- `path: string[] | undefined` — путь к директории с файлом.
+
+**Возвращает:** `PropertyList | undefined` — объект со свойствами или `undefined`, если путь не указан.
+
+```typescript
+const data = PropertiesTool.readFile('basic', ['src', 'theme', 'settings', 'button']);
+```
+
+## Операции
+
+### Механизм разрешения имен
+
+1. **Трансформация регистра**: Все входные имена компонентов перед объединением проходят через `toCamelCase`.
+2. **Префиксация**: Публичные методы всегда добавляют имя дизайна в начало, что предотвращает коллизии стилей при использовании нескольких тем одновременно.
+3. **Безопасное чтение**: При чтении файлов через `readFile` для конструктора используется глубокое копирование (`copyObject`), что исключает случайную мутацию глобальных базовых настроек в процессе работы других инструментов.
+
+## Примеры
+
+### Формирование CSS-класса для динамического компонента
+```typescript
+import { PropertiesTool } from '@dxtmisha/scripts'
+
+const design = 'basic'
+const component = 'input-field'
+
+const className = PropertiesTool.getClassName(design, component)
+// Результат: .basic-inputField
+```

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

@@ -0,0 +1,112 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/scripts/Classes/PropertiesTool - Tiện ích thuộc tính'/>
+
+# Lớp PropertiesTool
+
+Lớp `PropertiesTool` cung cấp một tập hợp các tiện ích tĩnh để xử lý việc đặt tên thành phần, phân giải đường dẫn và đọc các tệp cấu hình của hệ thống thiết kế. Nó đóng vai trò là một công cụ hỗ trợ cho các lớp khác, đảm bảo tính nhất quán trong quy ước đặt tên và cung cấp khả năng truy cập hiệu quả vào các tài nguyên tệp.
+
+## Các tính năng chính
+
+- **Chuẩn hóa Đặt tên** — tạo tên thành phần và tên lớp CSS nhất quán (camelCase).
+- **Logic Constructor** — bao gồm chức năng để xác định và tải các thuộc tính trình xây dựng cơ sở.
+- **Tích hợp Bộ nhớ đệm** — cung cấp khả năng đọc các tệp thuộc tính hiệu quả thông qua hệ thống bộ nhớ đệm.
+- **Cấu hình Linh hoạt** — lấy các định danh thiết kế đang hoạt động trực tiếp từ cài đặt môi trường.
+
+## Khởi tạo
+
+Lớp này chỉ cung cấp các phương thức tĩnh, vì vậy không cần phải khởi tạo thông qua `new`.
+
+```typescript
+import { PropertiesTool } from '@dxtmisha/scripts'
+
+// Gọi trực tiếp các phương thức tĩnh
+const isConst = PropertiesTool.isConstructor('basic')
+```
+
+## Các phương thức
+
+### `isConstructor`
+Kiểm tra xem tên thiết kế được cung cấp có khớp với khóa trình xây dựng (constructor) của hệ thống hay không. Điều này rất cần thiết để tách biệt các thuộc tính meta cơ sở khỏi các thuộc tính cụ thể liên quan đến chủ đề.
+
+**Tham số:**
+- `design: string` — tên thiết kế cần xác minh.
+
+**Trả về:** `boolean` — `true` nếu thiết kế là một trình xây dựng.
+
+```typescript
+const result = PropertiesTool.isConstructor('dxt.constructor');
+// Kết quả: true
+```
+
+### `getDesigns`
+Trả về danh sách các định danh thiết kế có sẵn trong môi trường hiện tại. Danh sách này bao gồm trình xây dựng hệ thống và thiết kế được chỉ định trong cấu hình chính của dự án.
+
+**Trả về:** `string[]` — một mảng gồm tên các thiết kế.
+
+```typescript
+const list = PropertiesTool.getDesigns();
+// Kết quả: ['dxt.constructor', 'my-project-design']
+```
+
+### `getComponentName`
+Tạo một chuỗi tên thành phần đã được chuẩn hóa bằng cách kết hợp tên thiết kế và tên thành phần. Tên thành phần được tự động chuyển đổi sang `camelCase`.
+
+**Tham số:**
+- `design: string` — tên thiết kế.
+- `component: string` (tùy chọn) — tên thành phần.
+
+**Trả về:** `string` — tên được tạo ra (ví dụ: `designName-componentName`).
+
+```typescript
+const name = PropertiesTool.getComponentName('basic', 'button-primary');
+// Kết quả: "basic-buttonPrimary"
+```
+
+### `getClassName`
+Tương tự như `getComponentName`, nhưng trả về một chuỗi được định dạng dưới dạng bộ chọn lớp CSS (bắt đầu bằng dấu chấm).
+
+**Tham số:**
+- `design: string` — tên thiết kế.
+- `component: string` (tùy chọn) — tên thành phần.
+
+**Trả về:** `string` — một chuỗi lớp CSS.
+
+```typescript
+const selector = PropertiesTool.getClassName('basic', 'button');
+// Kết quả: ".basic-button"
+```
+
+### `readFile`
+Đọc và trả về danh sách các thuộc tính (token) từ hệ thống tệp. Đối với trình xây dựng, nó trả về một bản sao của các thuộc tính cơ sở từ `properties.json`; đối với các trường hợp khác, nó đọc tệp thuộc tính thông qua bộ nhớ đệm hệ thống.
+
+**Tham số:**
+- `design: string` — tên thiết kế.
+- `path: string[] | undefined` — đường dẫn thư mục chứa tệp.
+
+**Trả về:** `PropertyList | undefined` — một đối tượng thuộc tính hoặc `undefined` nếu đường dẫn không được cung cấp.
+
+```typescript
+const data = PropertiesTool.readFile('basic', ['src', 'theme', 'settings', 'button']);
+```
+
+## Các thao tác (Operations)
+
+### Cơ chế phân giải tên (The Name Resolution Mechanism)
+
+1. **Chuyển đổi kiểu chữ**: Tất cả tên thành phần đầu vào đều trải qua `toCamelCase` trước khi được hợp nhất.
+2. **Thêm tiền tố**: Các phương thức công khai luôn thêm tên thiết kế vào đầu, giúp ngăn chặn xung đột kiểu khi sử dụng nhiều chủ đề cùng lúc.
+3. **Đọc tệp an toàn**: Khi đọc tệp thông qua `readFile` cho trình xây dựng, việc sao chép sâu (`copyObject`) được sử dụng để ngăn chặn sự thay đổi vô ý đối với các cài đặt cơ sở toàn cục bởi các công cụ khác.
+
+## Ví dụ (Examples)
+
+### Tạo một lớp CSS cho một thành phần động
+```typescript
+import { PropertiesTool } from '@dxtmisha/scripts'
+
+const design = 'basic'
+const component = 'input-field'
+
+const className = PropertiesTool.getClassName(design, component)
+// Kết quả: .basic-inputField
+```

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

@@ -0,0 +1,120 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/scripts/Classes/PropertiesTypes - Property Types'/>
+
+# PropertiesTypes Class
+
+The `PropertiesTypes` class serves as a system directory and analyzer for property types within the design system. Its primary role is to determine the property category (variable, selector, state, media query, etc.) based on special prefix symbols or key naming conventions.
+
+## Symbols and Types Mapping
+
+The system utilizes the following mapping of symbols to types:
+
+- `$` — **var** (CSS variable)
+- `::` — **virtual** (virtual element)
+- `:` — **selector** (SCSS selector)
+- `~` — **state** (state, e.g., :hover)
+- `#` — **subclass** (subclass)
+- `@@` — **linkClass** (link to a class)
+- `@` — **link** (link to a token)
+- `&&` — **root** (SCSS @at-root)
+- `&` — **scss** (SCSS selector)
+- `--` — **none** (ignored property)
+
+## Initialization
+
+The class contains only static methods and does not require instantiation via `new`.
+
+```typescript
+import { PropertiesTypes } from '@dxtmisha/scripts'
+
+// Using static methods
+const type = PropertiesTypes.getTypeInName('$primary-color')
+```
+
+## Methods
+
+### `isInType`
+Checks if the current property type is included in the specified list of allowed types. Used for filtering properties during the generation of specific blocks (e.g., media queries only).
+
+**Parameters:**
+- `type: PropertyItem['_type']` — the property type to verify.
+- `name: PropertyType[]` — an array of allowed types.
+
+**Returns:** `boolean` — `true` if the type matches one in the list.
+
+```typescript
+const isMedia = PropertiesTypes.isInType(type, ['media', 'media-max']);
+```
+
+### `isTypeInName`
+Determines if the provided name string (key) contains any of the reserved type symbols at the beginning.
+
+**Parameters:**
+- `name: string` — the property key name.
+
+**Returns:** `boolean` — `true` if a type symbol is identified.
+
+```typescript
+const hasSymbol = PropertiesTypes.isTypeInName('$myVar');
+// Result: true
+```
+
+### `isMedia`
+A specialized check to determine if the property type refers to media queries (`media` or `media-max`).
+
+**Parameters:**
+- `type: PropertyItem['_type']` — the property type.
+
+**Returns:** `boolean` — `true` if it is a media type.
+
+```typescript
+if (PropertiesTypes.isMedia(item.type)) { /* ... */ }
+```
+
+### `getTypeInName`
+The primary method for extracting the type from a key name. If a special symbol is found at the beginning of the key, the method returns its corresponding type. If no symbol is found but the key contains a `|` separator, the portion before the separator is converted to kebab-case and returned as the type.
+
+**Parameters:**
+- `name: string` — the property key name.
+
+**Returns:** `PropertyItem['_type']` — the identified type ID or `null`.
+
+```typescript
+const type1 = PropertiesTypes.getTypeInName('$color'); // 'var'
+const type2 = PropertiesTypes.getTypeInName('custom|value'); // 'custom'
+```
+
+### `getBySymbol`
+Returns the type name assigned to a specific symbol or string.
+
+**Parameters:**
+- `name: string` — the symbol (e.g., `$`).
+
+**Returns:** `string | undefined` — the type name (e.g., `var`).
+
+```typescript
+const typeName = PropertiesTypes.getBySymbol('$'); // 'var'
+```
+
+## Operations
+
+### The Recognition Mechanism via RegExp
+
+The symbol search in `PropertiesTypes` is implemented through a dynamic regular expression formed from the `SYMBOLS` dictionary keys. The `getExpSymbols` method creates an expression that:
+1. Searches for reserved symbols at the start of the string (e.g., `@`, `&&`, `~`).
+2. Searches for custom named types before a vertical bar (e.g., `media|...`).
+3. Groups the results for efficient type extraction by the `getTypeInName` method.
+
+## Examples
+
+### Identifying Types During Token Parsing
+```typescript
+import { PropertiesTypes } from '@dxtmisha/scripts'
+
+const keys = ['$primary', ':hover', '@link'];
+
+keys.forEach(key => {
+  console.log(`${key} is type: ${PropertiesTypes.getTypeInName(key)}`);
+});
+```