@rogolev/value 0.0.4 → 0.0.5

package/docs/classes/Expect/toBeString.md

@@ -0,0 +1,52 @@
+[Главная](../../../README.md) / [Классы](../classes.md) / [Expect](./Expect.md) / toBeString
+
+[Исходный код](../../../src/classes/Expect.mjs)
+
+# toBeString
+
+`toBeString` — Метод класса `Expect`, который проверяет, что фактическое значение является
+строкой.
+
+## Сигнатура метода
+
+```ts
+toBeString(message?: string): boolean;
+```
+
+## Описание
+
+Метод `toBeString` используется для проверки, что фактическое значение (`actual`) является строкой.
+Если значение не является строкой, выбрасывается ошибка типа `TypeError` с указанным сообщением.
+
+## Параметры
+
+- `message` (string): Сообщение об ошибке, если значение не является строкой. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является строкой.
+
+## Примеры использования
+
+1. Проверка значения, являющегося строкой:
+
+    ```js
+    const expect = new Expect('hello');
+    expect.toBeString(); // true
+    ```
+
+2. Проверка значения, не являющегося строкой:
+
+    ```js
+    const expect = new Expect(123);
+    try {
+        expect.toBeString('Значение должно быть строкой');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть строкой
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является строкой.

package/docs/classes/Expect/toBeSymbol.md

@@ -0,0 +1,53 @@
+[Главная](../../../README.md) / [Классы](../classes.md) / [Expect](./Expect.md) / toBeSymbol
+
+[Исходный код](../../../src/classes/Expect.mjs)
+
+# toBeSymbol
+
+`toBeSymbol` — Метод класса `Expect`, который проверяет, что фактическое значение является
+символом (Symbol).
+
+## Сигнатура метода
+
+```ts
+toBeSymbol(message?: string): boolean;
+```
+
+## Описание
+
+Метод `toBeSymbol` используется для проверки, что фактическое значение (`actual`) является символом
+(Symbol). Если значение не является символом, выбрасывается ошибка типа `TypeError` с указанным
+сообщением.
+
+## Параметры
+
+- `message` (string): Сообщение об ошибке, если значение не является символом. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является символом.
+
+## Примеры использования
+
+1. Проверка значения, являющегося символом:
+
+    ```js
+    const expect = new Expect(Symbol('example'));
+    expect.toBeSymbol(); // true
+    ```
+
+2. Проверка значения, не являющегося символом:
+
+    ```js
+    const expect = new Expect('example');
+    try {
+        expect.toBeSymbol('Значение должно быть символом');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть символом
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является символом.

package/docs/classes/Expect/toBeUndefined.md

@@ -0,0 +1,54 @@
+[Главная](../../../README.md) / [Классы](../classes.md) / [Expect](./Expect.md) / toBeUndefined
+
+[Исходный код](../../../src/classes/Expect.mjs)
+
+# toBeUndefined
+
+`toBeUndefined` — Метод класса `Expect`, который проверяет, что фактическое значение является
+undefined.
+
+## Сигнатура метода
+
+```ts
+toBeUndefined(message?: string): boolean;
+```
+
+## Описание
+
+Метод `toBeUndefined` используется для проверки, что фактическое значение (`actual`) является
+undefined. Если значение не является undefined, выбрасывается ошибка типа `TypeError` с указанным
+сообщением.
+
+## Параметры
+
+- `message` (string): Сообщение об ошибке, если значение не является undefined. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является undefined.
+
+## Примеры использования
+
+1. Проверка значения, являющегося undefined:
+
+    ```js
+    let value;
+    const expect = new Expect(value);
+    expect.toBeUndefined(); // true
+    ```
+
+2. Проверка значения, не являющегося undefined:
+
+    ```js
+    const expect = new Expect(123);
+    try {
+        expect.toBeUndefined('Значение должно быть undefined');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть undefined
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является undefined.

package/docs/classes/Expect/toEqual.md

@@ -0,0 +1,69 @@
+[Главная](../../../README.md) / [Классы](../classes.md) / [Expect](./Expect.md) / toEqual
+
+[Исходный код](../../../src/classes/Expect.mjs)
+
+# toEqual
+
+`toEqual` — Метод класса `Expect`, который проверяет, что фактическое значение эквивалентно
+ожидаемому значению.
+
+## Сигнатура метода
+
+```ts
+toEqual(expected: any, message?: string): boolean;
+```
+
+## Описание
+
+Метод `toEqual` используется для проверки, что фактическое значение (`actual`) эквивалентно
+ожидаемому значению (`expected`). Эквивалентность проверяется с использованием функции `is_equal`,
+которая рекурсивно сравнивает ключи и значения объектов и массивов. Если значения не эквивалентны,
+выбрасывается ошибка типа `TypeError` с указанным сообщением.
+
+## Параметры
+
+- `expected` (any): Ожидаемое значение для сравнения.
+- `message` (string): Сообщение об ошибке, если значения не эквивалентны. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значения эквивалентны.
+
+## Примеры использования
+
+1. Проверка эквивалентности чисел:
+
+    ```js
+    const expect = new Expect(5);
+    expect.toEqual(5); // true
+    ```
+
+2. Проверка эквивалентности строк:
+
+    ```js
+    const expect = new Expect('hello');
+    expect.toEqual('hello'); // true
+    ```
+
+3. Проверка эквивалентности объектов:
+
+    ```js
+    const expect = new Expect({ a: 1, b: 2 });
+    expect.toEqual({ a: 1, b: 2 }); // true
+    ```
+
+4. Проверка неэквивалентности с сообщением об ошибке:
+
+    ```js
+    const expect = new Expect(5);
+    try {
+        expect.toEqual(10, 'Значения не эквивалентны');
+    } catch (e) {
+        console.error(e.message); // Значения не эквивалентны
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значения не эквивалентны.

package/docs/classes/Expect/toStrictEqual.md

@@ -0,0 +1,70 @@
+[Главная](../../../README.md) / [Классы](../classes.md) / [Expect](./Expect.md) / toStrictEqual
+
+[Исходный код](../../../src/classes/Expect.mjs)
+
+# toStrictEqual
+
+`toStrictEqual` — Метод класса `Expect`, который проверяет, что фактическое значение строго
+эквивалентно ожидаемому значению.
+
+## Сигнатура метода
+
+```ts
+toStrictEqual(expected: any, message?: string): boolean;
+```
+
+## Описание
+
+Метод `toStrictEqual` используется для проверки, что фактическое значение (`actual`) строго
+эквивалентно ожидаемому значению (`expected`). Строгая эквивалентность проверяется с использованием
+функции `is_equal` в строгом режиме, которая рекурсивно сравнивает ключи и значения объектов и
+массивов с учетом типов. Если значения не строго эквивалентны, выбрасывается ошибка типа `TypeError`
+с указанным сообщением.
+
+## Параметры
+
+- `expected` (any): Ожидаемое значение для сравнения.
+- `message` (string): Сообщение об ошибке, если значения не строго эквивалентны. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значения строго эквивалентны.
+
+## Примеры использования
+
+1. Проверка строгой эквивалентности чисел:
+
+    ```js
+    const expect = new Expect(5);
+    expect.toStrictEqual(5); // true
+    ```
+
+2. Проверка строгой эквивалентности строк:
+
+    ```js
+    const expect = new Expect('hello');
+    expect.toStrictEqual('hello'); // true
+    ```
+
+3. Проверка строгой эквивалентности объектов:
+
+    ```js
+    const expect = new Expect({ a: 1, b: 2 });
+    expect.toStrictEqual({ a: 1, b: 2 }); // true
+    ```
+
+4. Проверка нестрогой эквивалентности с сообщением об ошибке:
+
+    ```js
+    const expect = new Expect(5);
+    try {
+        expect.toStrictEqual('5', 'Значения не строго эквивалентны');
+    } catch (e) {
+        console.error(e.message); // Значения не строго эквивалентны
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значения не строго эквивалентны.

package/docs/classes/Expect.md

@@ -0,0 +1,87 @@
+[Главная](../../README.md) / [Классы](../classes.md) / Expect
+
+[Исходный код](../../src/classes/Expect.mjs)
+
+# Expect
+
+`Expect` — Класс, предоставляющий методы для проверки значений в JavaScript.
+
+## Сигнатура класса
+
+```ts
+class Expect {
+    constructor(actual: any);
+
+    toBe(expected: any, message?: string): boolean;
+    toBeArray(message?: string): boolean;
+    toBeAssoc(message?: string): boolean;
+    toBeBigInt(message?: string): boolean;
+    toBeBool(message?: string): boolean;
+    toBeBoolean(message?: string): boolean;
+    toBeChar(message?: string): boolean;
+    toBeClass(message?: string): boolean;
+    toBeFloat(message?: string): boolean;
+    toBeFunction(message?: string): boolean;
+    toBeInfinity(message?: string): boolean;
+    toBeInt(message?: string): boolean;
+    toBeInteger(message?: string): boolean;
+    toBeList(message?: string): boolean;
+    toBeNaN(message?: string): boolean;
+    toBeNull(message?: string): boolean;
+    toBeNumber(message?: string): boolean;
+    toBeNumeric(message?: string): boolean;
+    toBeObject(message?: string): boolean;
+    toBeScalar(message?: string): boolean;
+    toBeString(message?: string): boolean;
+    toBeSymbol(message?: string): boolean;
+    toBeUndefined(message?: string): boolean;
+    toEqual(expected: any, message?: string): boolean;
+    toStrictEqual(expected: any, message?: string): boolean;
+}
+```
+
+## Описание
+
+Класс `Expect` используется для создания объектов, которые могут проверять различные свойства и типы
+значений. Он предоставляет методы для проверки, такие как `toBe`, `toBeArray`, `toBeBigInt` и многие
+другие. Каждый метод выбрасывает ошибку, если проверка не проходит, и возвращает `true`, если
+проверка успешна.
+
+### Методы
+
+- [toBe](./Expect/toBe.md) — Проверяет, что фактическое значение строго равно ожидаемому
+  значению.
+- [toBeArray](./Expect/toBeArray.md) — Проверяет, что фактическое значение является массивом.
+- [toBeAssoc](./Expect/toBeAssoc.md) — Проверяет, что фактическое значение является
+  ассоциативным массивом.
+- [toBeBigInt](./Expect/toBeBigInt.md) — Проверяет, что фактическое значение является BigInt.
+- [toBeBool](./Expect/toBeBool.md) — Проверяет, что фактическое значение является логическим
+  типом (boolean).
+- [toBeBoolean](./Expect/toBeBoolean.md) — Проверяет, что фактическое значение является
+  логическим типом (boolean).
+- [toBeChar](./Expect/toBeChar.md) — Проверяет, что фактическое значение является символом
+  (char).
+- [toBeClass](./Expect/toBeClass.md) — Проверяет, что фактическое значение является классом.
+- [toBeFloat](./Expect/toBeFloat.md) — Проверяет, что фактическое значение является числом с
+  плавающей запятой (float).
+- [toBeFunction](./Expect/toBeFunction.md) — Проверяет, является ли значение функцией.
+- [toBeInfinity](./Expect/toBeInfinity.md) — Проверяет, является ли значение бесконечностью
+  (Infinity).
+- [toBeInt](./Expect/toBeInt.md) — Проверяет, является ли значение целым числом (integer).
+- [toBeInteger](./Expect/toBeInteger.md) — Проверяет, является ли значение целым числом
+  (integer).
+- [toBeList](./Expect/toBeList.md) — Проверяет, является ли значение списком (list).
+- [toBeNaN](./Expect/toBeNaN.md) — Проверяет, является ли значение NaN (Not-a-Number).
+- [toBeNull](./Expect/toBeNull.md) — Проверяет, является ли значение null.
+- [toBeNumber](./Expect/toBeNumber.md) — Проверяет, является ли значение числом.
+- [toBeNumeric](./Expect/toBeNumeric.md) — Проверяет, является ли значение числовым.
+- [toBeObject](./Expect/toBeObject.md) — Проверяет, является ли значение объектом.
+- [toBeScalar](./Expect/toBeScalar.md) — Проверяет, является ли значение скалярным (boolean,
+  number, string, или symbol).
+- [toBeString](./Expect/toBeString.md) — Проверяет, является ли значение строкой.
+- [toBeSymbol](./Expect/toBeSymbol.md) — Проверяет, является ли значение символом (Symbol).
+- [toBeUndefined](./Expect/toBeUndefined.md) — Проверяет, является ли значение undefined.
+- [toEqual](./Expect/toEqual.md) — Проверяет, что фактическое значение эквивалентно ожидаемому
+  значению.
+- [toStrictEqual](./Expect/toStrictEqual.md) — Проверяет, что фактическое значение строго
+  эквивалентно ожидаемому значению.

package/docs/classes/Type/expectArray.md

@@ -0,0 +1,63 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / expectArray
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.expectArray
+
+`Type.expectArray` — Проверяет, является ли значение массивом, и выбрасывает ошибку с
+указанным сообщением, если это не так.
+
+## Сигнатура метода
+
+```ts
+static expectArray(value: any, message: string = ''): boolean;
+```
+
+## Описание
+
+Метод `expectArray` используется для проверки, является ли переданное значение массивом. Если
+значение не является массивом, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+
+## Параметры
+
+- `value` (any): Значение для проверки.
+- `message` (string): Сообщение об ошибке, если значение не является массивом. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является массивом.
+
+## Примеры использования
+
+1. Проверка значения, являющегося массивом:
+
+    ```js
+    const array = [1, 2, 3];
+    const result = Type.expectArray(array);
+    console.log(result); // true
+    ```
+
+2. Проверка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = Type.expectArray('not an array', 'Значение должно быть массивом.');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть массивом.
+    }
+    ```
+
+3. Проверка значения с использованием пользовательского сообщения об ошибке:
+
+    ```js
+    try {
+        const result = Type.expectArray(123, 'Ожидался массив.');
+    } catch (e) {
+        console.error(e.message); // Ожидался массив.
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является массивом или если параметр `message` не является строкой.

package/docs/classes/Type/expectAssoc.md

@@ -0,0 +1,65 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / expectAssoc
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.expectAssoc
+
+`Type.expectAssoc` — Проверяет, является ли значение ассоциативным массивом, и выбрасывает
+ошибку с указанным сообщением, если это не так.
+
+## Сигнатура метода
+
+```ts
+static expectAssoc(value: any, message: string = ''): boolean;
+```
+
+## Описание
+
+Метод `expectAssoc` используется для проверки, является ли переданное значение ассоциативным
+массивом. Если значение не является ассоциативным массивом, метод выбрасывает ошибку типа
+`TypeError` с указанным сообщением.
+
+## Параметры
+
+- `value` (any): Значение для проверки.
+- `message` (string): Сообщение об ошибке, если значение не является ассоциативным массивом. По
+  умолчанию пустая строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является ассоциативным массивом.
+
+## Примеры использования
+
+1. Проверка значения, являющегося ассоциативным массивом:
+
+    ```js
+    const assoc = { a: 1, b: 2, c: 3 };
+    const result = Type.expectAssoc(assoc);
+    console.log(result); // true
+    ```
+
+2. Проверка значения, не являющегося ассоциативным массивом:
+
+    ```js
+    try {
+        const result = Type.expectAssoc([1, 2, 3], 'Значение должно быть ассоциативным массивом.');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть ассоциативным массивом.
+    }
+    ```
+
+3. Проверка значения с использованием пользовательского сообщения об ошибке:
+
+    ```js
+    try {
+        const result = Type.expectAssoc(123, 'Ожидался ассоциативный массив.');
+    } catch (e) {
+        console.error(e.message); // Ожидался ассоциативный массив.
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является ассоциативным массивом или если параметр `message` не
+  является строкой.

package/docs/classes/Type/expectBigInt.md

@@ -0,0 +1,63 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / expectBigInt
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.expectBigInt
+
+`Type.expectBigInt` — Проверяет, является ли значение BigInt, и выбрасывает ошибку с указанным
+сообщением, если это не так.
+
+## Сигнатура метода
+
+```ts
+static expectBigInt(value: any, message: string = ''): boolean;
+```
+
+## Описание
+
+Метод `expectBigInt` используется для проверки, является ли переданное значение BigInt. Если
+значение не является BigInt, метод выбрасывает ошибку типа `TypeError` с указанным сообщением.
+
+## Параметры
+
+- `value` (any): Значение для проверки.
+- `message` (string): Сообщение об ошибке, если значение не является BigInt. По умолчанию пустая
+  строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является BigInt.
+
+## Примеры использования
+
+1. Проверка значения, являющегося BigInt:
+
+    ```js
+    const value = 123n;
+    const result = Type.expectBigInt(value);
+    console.log(result); // true
+    ```
+
+2. Проверка значения, не являющегося BigInt:
+
+    ```js
+    try {
+        const result = Type.expectBigInt(123, 'Значение должно быть BigInt.');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть BigInt.
+    }
+    ```
+
+3. Проверка значения с использованием пользовательского сообщения об ошибке:
+
+    ```js
+    try {
+        const result = Type.expectBigInt('123', 'Ожидался BigInt.');
+    } catch (e) {
+        console.error(e.message); // Ожидался BigInt.
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является BigInt или если параметр `message` не является строкой.

package/docs/classes/Type/expectBool.md

@@ -0,0 +1,65 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / expectBool
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.expectBool
+
+`Type.expectBool` — Проверяет, является ли значение логическим типом, и выбрасывает ошибку с
+указанным сообщением, если это не так.
+
+## Сигнатура метода
+
+```ts
+static expectBool(value: any, message: string = ''): boolean;
+```
+
+## Описание
+
+Метод `expectBool` используется для проверки, является ли переданное значение логическим типом. Если
+значение не является логическим типом, метод выбрасывает ошибку типа `TypeError` с указанным
+сообщением.
+
+## Параметры
+
+- `value` (any): Значение для проверки.
+- `message` (string): Сообщение об ошибке, если значение не является логическим типом. По умолчанию
+  пустая строка.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является логическим типом.
+
+## Примеры использования
+
+1. Проверка значения, являющегося логическим типом:
+
+    ```js
+    const value = true;
+    const result = Type.expectBool(value);
+    console.log(result); // true
+    ```
+
+2. Проверка значения, не являющегося логическим типом:
+
+    ```js
+    try {
+        const result = Type.expectBool(123, 'Значение должно быть логическим типом.');
+    } catch (e) {
+        console.error(e.message); // Значение должно быть логическим типом.
+    }
+    ```
+
+3. Проверка значения с использованием пользовательского сообщения об ошибке:
+
+    ```js
+    try {
+        const result = Type.expectBool('true', 'Ожидался логический тип.');
+    } catch (e) {
+        console.error(e.message); // Ожидался логический тип.
+    }
+    ```
+
+## Исключения
+
+- `TypeError`: Если значение не является логическим типом или если параметр `message` не является
+  строкой.