@rogolev/value 0.0.3 → 0.0.5

package/docs/classes/Type.md

@@ -1,6 +1,6 @@
 [Главная](../../README.md) / [Классы](../classes.md) / Type
 
-[Исходный код](../../src/classes/Type.mjs)
+[Исходный код](../../src/classes/mjs)
 
 # Type
 
@@ -10,6 +10,45 @@
 
 ```ts
 class Type {
+    /** Константы */
+    static readonly NULL: string;
+    static readonly NAN: string;
+    static readonly UNDEFINED: string;
+    static readonly INFINITY: string;
+    static readonly BOOLEAN: string;
+    static readonly INTEGER: string;
+    static readonly BIGINT: string;
+    static readonly FLOAT: string;
+    static readonly STRING: string;
+    static readonly SYMBOL: string;
+    static readonly CLASS: string;
+    static readonly FUNCTION: string;
+    static readonly ARRAY: string;
+    static readonly OBJECT: string;
+
+    /** Методы */
+    static expectArray(value: any, message?: string): boolean;
+    static expectAssoc(value: any, message?: string): boolean;
+    static expectBigInt(value: any, message?: string): boolean;
+    static expectBool(value: any, message?: string): boolean;
+    static expectBoolean(value: any, message?: string): boolean;
+    static expectChar(value: any, message?: string): boolean;
+    static expectClass(value: any, message?: string): boolean;
+    static expectFloat(value: any, message?: string): boolean;
+    static expectFunction(value: any, message?: string): boolean;
+    static expectInfinity(value: any, message?: string): boolean;
+    static expectInt(value: any, message?: string): boolean;
+    static expectInteger(value: any, message?: string): boolean;
+    static expectList(value: any, message?: string): boolean;
+    static expectNaN(value: any, message?: string): boolean;
+    static expectNull(value: any, message?: string): boolean;
+    static expectNumber(value: any, message?: string): boolean;
+    static expectNumeric(value: any, message?: string): boolean;
+    static expectObject(value: any, message?: string): boolean;
+    static expectScalar(value: any, message?: string): boolean;
+    static expectString(value: any, message?: string): boolean;
+    static expectSymbol(value: any, message?: string): boolean;
+    static expectUndefined(value: any, message?: string): boolean;
     static isEmpty(value: any): boolean;
     static isArray(value: any): boolean;
     static isAssoc(value: any): boolean;
@@ -41,8 +80,69 @@ class Type {
 значений. Эти методы охватывают широкий спектр типов данных, включая примитивы, объекты, массивы,
 функции и специальные значения.
 
+### Константы
+
+- `NULL` — Константа, представляющая значение `null`.
+- `NAN` — Константа, представляющая значение `NaN` (Not-a-Number).
+- `UNDEFINED` — Константа, представляющая значение `undefined`.
+- `INFINITY` — Константа, представляющая значение `Infinity`.
+- `BOOLEAN` — Константа, представляющая тип `boolean`.
+- `INTEGER` — Константа, представляющая тип `integer` (целое число).
+- `BIGINT` — Константа, представляющая тип `bigint` (большое целое число).
+- `FLOAT` — Константа, представляющая тип `float` (число с плавающей запятой).
+- `STRING` — Константа, представляющая тип `string`.
+- `SYMBOL` — Константа, представляющая тип `symbol`.
+- `CLASS` — Константа, представляющая тип `class`.
+- `FUNCTION` — Константа, представляющая тип `function`.
+- `ARRAY` — Константа, представляющая тип `array`.
+- `OBJECT` — Константа, представляющая тип `object`.
+
 ### Методы
 
+- [expectArray](./Type/expectArray.md) — Проверяет, является ли значение массивом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectAssoc](./Type/expectAssoc.md) — Проверяет, является ли значение ассоциативным
+  массивом, и выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectBigInt](./Type/expectBigInt.md) — Проверяет, является ли значение BigInt, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectBool](./Type/expectBool.md) — Проверяет, является ли значение логическим типом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectBoolean](./Type/expectBoolean.md) — Проверяет, является ли значение логическим типом,
+  и выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectChar](./Type/expectChar.md) — Проверяет, является ли значение символом, и выбрасывает
+  ошибку с указанным сообщением, если это не так.
+- [expectClass](./Type/expectClass.md) — Проверяет, является ли значение классом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectFloat](./Type/expectFloat.md) — Проверяет, является ли значение числом с плавающей
+  запятой, и выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectFunction](./Type/expectFunction.md) — Проверяет, является ли значение функцией, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectInfinity](./Type/expectInfinity.md) — Проверяет, является ли значение бесконечностью,
+  и выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectInt](./Type/expectInt.md) — Проверяет, является ли значение целым числом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectInteger](./Type/expectInteger.md) — Проверяет, является ли значение целым числом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectList](./Type/expectList.md) — Проверяет, является ли значение списком, и выбрасывает
+  ошибку с указанным сообщением, если это не так.
+- [expectNaN](./Type/expectNaN.md) — Проверяет, является ли значение NaN, и выбрасывает ошибку
+  с указанным сообщением, если это не так.
+- [expectNull](./Type/expectNull.md) — Проверяет, является ли значение null, и выбрасывает
+  ошибку с указанным сообщением, если это не так.
+- [expectNumber](./Type/expectNumber.md) — Проверяет, является ли значение числом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectNumeric](./Type/expectNumeric.md) — Проверяет, является ли значение числовым, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectObject](./Type/expectObject.md) — Проверяет, является ли значение объектом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectScalar](./Type/expectScalar.md) — Проверяет, является ли значение скалярным, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectString](./Type/expectString.md) — Проверяет, является ли значение строкой, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectSymbol](./Type/expectSymbol.md) — Проверяет, является ли значение символом, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
+- [expectUndefined](./Type/expectUndefined.md) — Проверяет, является ли значение undefined, и
+  выбрасывает ошибку с указанным сообщением, если это не так.
 - [isEmpty](./Type/isEmpty.md) — Проверяет, является ли переменная пустой.
 - [isArray](./Type/isArray.md) — Проверяет, является ли переданное значение массивом или
   ассоциативным массивом.
@@ -71,4 +171,3 @@ class Type {
 - [isString](./Type/isString.md) — Проверяет, является ли значение строкой.
 - [isSymbol](./Type/isSymbol.md) — Проверяет, является ли значение символом.
 - [isUndefined](./Type/isUndefined.md) — Проверяет, является ли значение `undefined`.
-

package/docs/classes.md

@@ -4,8 +4,9 @@
 
 - [Convert](./classes/Convert.md) — Класс, предоставляющий методы для преобразования различных
   типов данных в JavaScript.
+- [Expect](./classes/Expect.md) — Класс, предоставляющий методы для проверки значений в
+  JavaScript.
 - [Type](./classes/Type.md) — Класс, предоставляющий методы для проверки типов данных в
   JavaScript.
 - [Value](./classes/Value.md) — Класс, представляющий обертку для значений различных типов и
   предоставляющий методы для работы с ними.
-

package/docs/helpers/array/array_chunk.md

@@ -0,0 +1,80 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_chunk
+
+[Исходный код](../../../src/helpers/array/array_chunk.mjs)
+
+# array_chunk
+
+`array_chunk` — Разбивает массив на части указанной длины.
+
+## Сигнатура функции
+
+```ts
+function array_chunk(value: array, length: number): array;
+```
+
+## Описание
+
+Функция `array_chunk` используется для разбивки массива на части указанной длины. Если переданное
+значение не является массивом, функция выбрасывает ошибку типа `TypeError`. Если длина не является
+целым числом или меньше 1, функция выбрасывает соответствующую ошибку.
+
+## Параметры
+
+- `value` (array): Массив, который необходимо разбить на части.
+- `length` (number): Длина каждой части.
+
+## Возвращаемое значение
+
+Возвращает новый массив, содержащий части исходного массива.
+
+## Примеры использования
+
+1. Разбивка массива на части указанной длины:
+
+    ```js
+    const array = [1, 2, 3, 4, 5];
+    const result = array_chunk(array, 2);
+    console.log(result); // [[1, 2], [3, 4], [5]]
+    ```
+
+2. Обработка пустого массива:
+
+    ```js
+    const array = [];
+    const result = array_chunk(array, 2);
+    console.log(result); // []
+    ```
+
+3. Обработка ассоциативного массива:
+
+    ```js
+    const assoc = { key1: 'value1', key2: 'value2', key3: 'value3', key4: 'value4' };
+    const result = array_chunk(assoc, 2);
+    console.log(result); // [['value1', 'value2'], ['value3', 'value4']]
+    ```
+
+4. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_chunk('not an array', 2);
+    } catch (e) {
+        console.error(e.message); // Параметр "value" должен быть массивом.
+    }
+    ```
+
+5. Обработка некорректной длины:
+
+    ```js
+    try {
+        const result = array_chunk([1, 2, 3], 'not an integer');
+    } catch (e) {
+        console.error(e.message); // Параметр "length" должен быть целым числом.
+    }
+
+    try {
+        const result = array_chunk([1, 2, 3], 0);
+    } catch (e) {
+        console.error(e.message); // Параметр "length" должен быть больше нуля.
+    }
+    ```

package/docs/helpers/array/array_chunk_with_keys.md

@@ -0,0 +1,81 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_chunk_with_keys
+
+[Исходный код](../../../src/helpers/array/array_chunk_with_keys.mjs)
+
+# array_chunk_with_keys
+
+`array_chunk_with_keys` — Разбивает массив на части указанной длины с сохранением ключей.
+
+## Сигнатура функции
+
+```ts
+function array_chunk_with_keys(value: array, length: number): array;
+```
+
+## Описание
+
+Функция `array_chunk_with_keys` используется для разбивки массива на части указанной длины с
+сохранением ключей. Если переданное значение не является массивом, функция выбрасывает ошибку типа
+`TypeError`. Если длина не является целым числом или меньше 1, функция выбрасывает соответствующую
+ошибку.
+
+## Параметры
+
+- `value` (array): Массив, который необходимо разбить на части.
+- `length` (number): Длина каждой части.
+
+## Возвращаемое значение
+
+Возвращает новый массив, содержащий части исходного массива с сохранением ключей.
+
+## Примеры использования
+
+1. Разбивка ассоциативного массива на части указанной длины с сохранением ключей:
+
+    ```js
+    const assoc = { a: 1, b: 2, c: 3, d: 4, e: 5 };
+    const result = array_chunk_with_keys(assoc, 2);
+    console.log(result); // [{ a: 1, b: 2 }, { c: 3, d: 4 }, { e: 5 }]
+    ```
+
+2. Обработка пустого ассоциативного массива:
+
+    ```js
+    const assoc = {};
+    const result = array_chunk_with_keys(assoc, 2);
+    console.log(result); // []
+    ```
+
+3. Разбивка обычного массива на части указанной длины с сохранением ключей:
+
+    ```js
+    const array = [1, 2, 3, 4, 5];
+    const result = array_chunk_with_keys(array, 2);
+    console.log(result); // [{ 0: 1, 1: 2 }, { 2: 3, 3: 4 }, { 4: 5 }]
+    ```
+
+4. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_chunk_with_keys('not an array', 2);
+    } catch (e) {
+        console.error(e.message); // Параметр "value" должен быть массивом.
+    }
+    ```
+
+5. Обработка некорректной длины:
+
+    ```js
+    try {
+        const result = array_chunk_with_keys([1, 2, 3], 'not an integer');
+    } catch (e) {
+        console.error(e.message); // Параметр "length" должен быть целым числом.
+    }
+
+    try {
+        const result = array_chunk_with_keys([1, 2, 3], 0);
+    } catch (e) {
+        console.error(e.message); // Параметр "length" должен быть больше нуля.
+    }
+    ```

package/docs/helpers/array/array_column.md

@@ -0,0 +1,110 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_column
+
+[Исходный код](../../../src/helpers/array/array_column.mjs)
+
+# array_column
+
+`array_column` — Извлекает значения указанного столбца из массива объектов.
+
+## Сигнатура функции
+
+```ts
+function array_column(
+    value: array,
+    column_key: string | number,
+    index_key?: string | number | null,
+): array | object;
+```
+
+## Описание
+
+Функция `array_column` используется для извлечения значений указанного столбца из массива объектов.
+Если переданное значение не является списком, функция выбрасывает ошибку типа `TypeError`. Если ключ
+столбца или индексный ключ не являются строкой или целым числом, функция выбрасывает соответствующую
+ошибку.
+
+## Параметры
+
+- `value` (array): Массив объектов, из которого необходимо извлечь значения.
+- `column_key` (string | number): Ключ столбца, значения которого необходимо извлечь.
+- `index_key` (string | number | null): Ключ, который будет использоваться для индексации
+  возвращаемого массива (по умолчанию `null`).
+
+## Возвращаемое значение
+
+Возвращает массив значений указанного столбца. Если указан индексный ключ, возвращает объект с
+индексированными значениями.
+
+## Примеры использования
+
+1. Извлечение значений указанного столбца из массива объектов:
+
+    ```js
+    const array = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+    ];
+    const result = array_column(array, 'name');
+    console.log(result); // ['Alice', 'Bob', 'Charlie']
+    ```
+
+2. Извлечение значений указанного столбца с использованием индексного ключа:
+
+    ```js
+    const array = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+    ];
+    const result = array_column(array, 'name', 'id');
+    console.log(result); // { 1: 'Alice', 2: 'Bob', 3: 'Charlie' }
+    ```
+
+3. Обработка пустого массива:
+
+    ```js
+    const array = [];
+    const result = array_column(array, 'name');
+    console.log(result); // []
+    ```
+
+4. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_column('not an array', 'name');
+    } catch (e) {
+        console.error(e.message); // Параметр "value" должен быть списком.
+    }
+    ```
+
+5. Обработка некорректного ключа столбца:
+
+    ```js
+    const array = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+    ];
+    try {
+        const result = array_column(array, {});
+    } catch (e) {
+        console.error(e.message); // Параметр "column_key" должен быть строкой или целым числом.
+    }
+    ```
+
+6. Обработка некорректного индексного ключа:
+
+    ```js
+    const array = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+    ];
+    try {
+        const result = array_column(array, 'name', {});
+    } catch (e) {
+        console.error(e.message); // Параметр "index_key" должен быть строкой или целым числом.
+    }
+    ```

package/docs/helpers/array/array_combine.md

@@ -0,0 +1,77 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_combine
+
+[Исходный код](../../../src/helpers/array/array_combine.mjs)
+
+# array_combine
+
+`array_combine` — Объединяет два массива в ассоциативный массив.
+
+## Сигнатура функции
+
+```ts
+function array_combine(keys: array, values: array): object;
+```
+
+## Описание
+
+Функция `array_combine` используется для объединения двух массивов в ассоциативный массив. Если
+переданное значение для ключей или значений не является списком, функция выбрасывает ошибку типа
+`TypeError`. Если количество ключей и значений не совпадает, функция выбрасывает ошибку.
+
+## Параметры
+
+- `keys` (array): Массив ключей.
+- `values` (array): Массив значений.
+
+## Возвращаемое значение
+
+Возвращает ассоциативный массив, где ключи из первого массива соответствуют значениям из второго
+массива.
+
+## Примеры использования
+
+1. Объединение двух массивов в ассоциативный массив:
+
+    ```js
+    const keys = ['a', 'b', 'c'];
+    const values = [1, 2, 3];
+    const result = array_combine(keys, values);
+    console.log(result); // { a: 1, b: 2, c: 3 }
+    ```
+
+2. Обработка пустых массивов:
+
+    ```js
+    const keys = [];
+    const values = [];
+    const result = array_combine(keys, values);
+    console.log(result); // {}
+    ```
+
+3. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_combine('not an array', [1, 2, 3]);
+    } catch (e) {
+        console.error(e.message); // Параметр "keys" должен быть списком.
+    }
+
+    try {
+        const result = array_combine(['a', 'b', 'c'], 'not an array');
+    } catch (e) {
+        console.error(e.message); // Параметр "values" должен быть списком.
+    }
+    ```
+
+4. Обработка некорректного количества ключей и значений:
+
+    ```js
+    const keys = ['a', 'b'];
+    const values = [1, 2, 3];
+    try {
+        const result = array_combine(keys, values);
+    } catch (e) {
+        console.error(e.message); // Количество элементов в списке ключей должно ровняться количеству элементов в списке значений.
+    }
+    ```

package/docs/helpers/array/array_count_values.md

@@ -0,0 +1,71 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_count_values
+
+[Исходный код](../../../src/helpers/array/array_count_values.mjs)
+
+# array_count_values
+
+`array_count_values` — Подсчитывает количество значений в массиве.
+
+## Сигнатура функции
+
+```ts
+function array_count_values(value: object): object;
+```
+
+## Описание
+
+Функция `array_count_values` используется для подсчета количества значений в массиве. Если
+переданное значение не является массивом, функция выбрасывает ошибку типа `TypeError`.
+
+## Параметры
+
+- `value` (array): Массив значений, которые необходимо подсчитать.
+
+## Возвращаемое значение
+
+Возвращает объект, где ключи представляют уникальные значения из массива, а значения представляют
+количество их вхождений.
+
+## Примеры использования
+
+1. Подсчет количества значений в массиве:
+
+    ```js
+    const array = ['a', 'b', 'a', 'c', 'b', 'a'];
+    const result = array_count_values(array);
+    console.log(result); // { a: 3, b: 2, c: 1 }
+    ```
+
+2. Обработка пустого массива:
+
+    ```js
+    const array = [];
+    const result = array_count_values(array);
+    console.log(result); // {}
+    ```
+
+3. Обработка значений разных типов:
+
+    ```js
+    const array = [1, '1', true, 'true', null, 'null', undefined, 'undefined'];
+    const result = array_count_values(array);
+    console.log(result); // { 1: 2, true: 2, null: 2, undefined: 2 }
+    ```
+
+4. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_count_values('not an array');
+    } catch (e) {
+        console.error(e.message); // Параметр "value" должен быть массивом.
+    }
+    ```
+
+5. Обработка ассоциативных массивов:
+
+    ```js
+    const assoc = { key1: 'a', key2: 'b', key3: 'a', key4: 'c' };
+    const result = array_count_values(assoc);
+    console.log(result); // { a: 2, b: 1, c: 1 }
+    ```

package/docs/helpers/array/array_diff.md

@@ -0,0 +1,97 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_diff
+
+[Исходный код](../../../src/helpers/array/array_diff.mjs)
+
+# array_diff
+
+`array_diff` — Вычисляет расхождение между массивами.
+
+## Сигнатура функции
+
+```ts
+function array_diff(original_array: object, ...arrays: object[]): object;
+```
+
+## Описание
+
+Функция `array_diff` используется для вычисления расхождения между массивами. Она возвращает
+ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+
+## Параметры
+
+- `original_array` (object): Исходный массив.
+- `...arrays` (object): Массивы для сравнения.
+
+## Возвращаемое значение
+
+Возвращает ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в
+других массивах.
+
+## Примеры использования
+
+1. Сравнение массивов:
+
+    ```js
+    const original_array = [1, 2, 3];
+    const array1 = [1, 2];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 2: 3 }
+    ```
+
+2. Обработка пустых массивов:
+
+    ```js
+    const original_array = [];
+    const array1 = [];
+    const result = array_diff(original_array, array1);
+    console.log(result); // {}
+    ```
+
+3. Сравнение массивов с различными типами данных:
+
+    ```js
+    const original_array = [1, '2', true];
+    const array1 = [1, 2, false];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 1: '2', 2: true }
+    ```
+
+4. Сравнение массивов с объектами:
+
+    ```js
+    const original_array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+    const array1 = [{ id: 1 }, { id: 2 }];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 2: { id: 3 } }
+    ```
+
+5. Сравнение ассоциативных массивов:
+
+    ```js
+    const original_array = { a: 1, b: 2, c: 3 };
+    const array1 = { a: 1, b: 2 };
+    const result = array_diff(original_array, array1);
+    console.log(result); // { c: 3 }
+    ```
+
+6. Сравнение нескольких массивов:
+
+    ```js
+    const original_array = [1, 2, 3, 4];
+    const array1 = [1, 2];
+    const array2 = [3];
+    const result = array_diff(original_array, array1, array2);
+    console.log(result); // { 3: 4 }
+    ```
+
+7. Сравнение массивов с вложенными структурами:
+
+    ```js
+    const original_array = [
+        { id: 1, data: [1, 2] },
+        { id: 2, data: [3, 4] },
+    ];
+    const array1 = [{ id: 1, data: [1, 2] }];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 1: { id: 2, data: [3, 4] } }
+    ```