@rogolev/value 0.0.1 → 0.0.3

package/src/constants.mjs

@@ -0,0 +1,14 @@
+export const TYPE_NULL = 'null';
+export const TYPE_NAN = 'NaN';
+export const TYPE_UNDEFINED = 'undefined';
+export const TYPE_INFINITY = 'infinity';
+export const TYPE_BOOLEAN = 'boolean';
+export const TYPE_INTEGER = 'integer';
+export const TYPE_BIGINT = 'bigint';
+export const TYPE_FLOAT = 'float';
+export const TYPE_STRING = 'string';
+export const TYPE_SYMBOL = 'symbol';
+export const TYPE_CLASS = 'class';
+export const TYPE_FUNCTION = 'function';
+export const TYPE_ARRAY = 'array';
+export const TYPE_OBJECT = 'object';

package/src/helpers/gettype.mjs

@@ -12,6 +12,22 @@ import is_bool from './is_bool.mjs';
 import is_string from './is_string.mjs';
 import is_symbol from './is_symbol.mjs';
 import is_function from './is_function.mjs';
+import {
+    TYPE_ARRAY,
+    TYPE_BIGINT,
+    TYPE_BOOLEAN,
+    TYPE_CLASS,
+    TYPE_FLOAT,
+    TYPE_FUNCTION,
+    TYPE_INFINITY,
+    TYPE_INTEGER,
+    TYPE_NAN,
+    TYPE_NULL,
+    TYPE_OBJECT,
+    TYPE_STRING,
+    TYPE_SYMBOL,
+    TYPE_UNDEFINED,
+} from '../constants.mjs';
 
 /**
  * Определяет тип переданного значения.
@@ -74,59 +90,59 @@ import is_function from './is_function.mjs';
  */
 export default function gettype(value) {
     if (is_null(value)) {
-        return 'null';
+        return TYPE_NULL;
     }
 
     if (is_nan(value)) {
-        return 'NaN';
+        return TYPE_NAN;
     }
 
     if (is_undefined(value)) {
-        return 'undefined';
+        return TYPE_UNDEFINED;
     }
 
     if (is_infinity(value)) {
-        return 'infinity';
+        return TYPE_INFINITY;
     }
 
     if (is_bool(value)) {
-        return 'boolean';
+        return TYPE_BOOLEAN;
     }
 
     if (is_int(value)) {
-        return 'integer';
+        return TYPE_INTEGER;
     }
 
     if (is_bigint(value)) {
-        return 'bigint';
+        return TYPE_BIGINT;
     }
 
     if (is_float(value)) {
-        return 'float';
+        return TYPE_FLOAT;
     }
 
     if (is_string(value)) {
-        return 'string';
+        return TYPE_STRING;
     }
 
     if (is_symbol(value)) {
-        return 'symbol';
+        return TYPE_SYMBOL;
     }
 
     if (is_class(value)) {
-        return 'class';
+        return TYPE_CLASS;
     }
 
     if (is_function(value)) {
-        return 'function';
+        return TYPE_FUNCTION;
     }
 
     if (is_array(value)) {
-        return 'array';
+        return TYPE_ARRAY;
     }
 
     if (is_object(value)) {
-        return 'object';
+        return TYPE_OBJECT;
     }
 
     return typeof value;

package/src/helpers/value.mjs

@@ -0,0 +1,92 @@
+import Value from '../classes/Value.mjs';
+
+/**
+ * Создает новый экземпляр класса `Value` с заданным значением.
+ *
+ * ### Описание
+ *
+ * Функция `value` используется для создания нового экземпляра класса `Value` с переданным значением.
+ * Это позволяет легко обернуть значение в экземпляр класса `Value` и использовать методы класса для работы с этим значением.
+ *
+ * ### Параметры
+ *
+ * - `val` (any)
+ *      Значение, которое необходимо обернуть в экземпляр класса `Value`.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает новый экземпляр класса `Value` с переданным значением.
+ *
+ * ### Примеры использования
+ *
+ * 1. Создание экземпляра класса `Value` с числом:
+ *
+ *    ```js
+ *    const valueInstance = value(123);
+ *    console.log(valueInstance.get()); // 123
+ *    console.log(valueInstance.getType()); // 'integer'
+ *    console.log(valueInstance.isNumber()); // true
+ *    ```
+ *
+ * 2. Создание экземпляра класса `Value` со строкой:
+ *
+ *    ```js
+ *    const valueInstance = value('example');
+ *    console.log(valueInstance.get()); // 'example'
+ *    console.log(valueInstance.getType()); // 'string'
+ *    console.log(valueInstance.isString()); // true
+ *    ```
+ *
+ * 3. Создание экземпляра класса `Value` с объектом:
+ *
+ *    ```js
+ *    const obj = { key: 'value' };
+ *    const valueInstance = value(obj);
+ *    console.log(valueInstance.get()); // { key: 'value' }
+ *    console.log(valueInstance.getType()); // 'object'
+ *    console.log(valueInstance.isObject()); // true
+ *    ```
+ *
+ * 4. Создание экземпляра класса `Value` с массивом:
+ *
+ *    ```js
+ *    const arr = [1, 2, 3];
+ *    const valueInstance = value(arr);
+ *    console.log(valueInstance.get()); // [1, 2, 3]
+ *    console.log(valueInstance.getType()); // 'array'
+ *    console.log(valueInstance.isArray()); // true
+ *    ```
+ *
+ * 5. Создание экземпляра класса `Value` с булевым значением:
+ *
+ *    ```js
+ *    const valueInstance = value(true);
+ *    console.log(valueInstance.get()); // true
+ *    console.log(valueInstance.getType()); // 'boolean'
+ *    console.log(valueInstance.isBool()); // true
+ *    ```
+ *
+ * 6. Создание экземпляра класса `Value` с null:
+ *
+ *    ```js
+ *    const valueInstance = value(null);
+ *    console.log(valueInstance.get()); // null
+ *    console.log(valueInstance.getType()); // 'null'
+ *    console.log(valueInstance.isNull()); // true
+ *    ```
+ *
+ * 7. Создание экземпляра класса `Value` с undefined:
+ *
+ *    ```js
+ *    const valueInstance = value(undefined);
+ *    console.log(valueInstance.get()); // undefined
+ *    console.log(valueInstance.getType()); // 'undefined'
+ *    console.log(valueInstance.isUndefined()); // true
+ *    ```
+ *
+ * @param {any} val Значение, которое необходимо обернуть в экземпляр класса `Value`.
+ * @returns {Value} Возвращает новый экземпляр класса `Value` с переданным значением.
+ */
+export default function value(val) {
+    return new Value(val);
+}

package/tests/classes/Convert.test.mjs

@@ -0,0 +1,398 @@
+import { expect, test, describe } from '@jest/globals';
+import { Convert } from '../../index.mjs';
+
+describe('Класс Convert', () => {
+    describe('Метод Convert.toArray', () => {
+        test('Должен возвращать пустой массив для null и undefined', () => {
+            expect(Convert.toArray(null)).toEqual([]);
+            expect(Convert.toArray(undefined)).toEqual([]);
+        });
+
+        test('Должен возвращать исходный массив, если он передан', () => {
+            const input = [1, 2, 3];
+            expect(Convert.toArray(input)).toBe(input);
+        });
+
+        test('Должен возвращать ассоциативный массив без прототипа и с итератором Symbol.iterator при передаче объекта', () => {
+            const result = Convert.toArray({ key: 'value' });
+
+            expect(Object.getPrototypeOf(result)).toBeNull();
+
+            for (const entry of result) {
+                expect(entry).toEqual(['key', 'value']);
+            }
+        });
+
+        test('Должен возвращать массив с примитивными значениями', () => {
+            expect(Convert.toArray(true)).toEqual([true]);
+            expect(Convert.toArray(false)).toEqual([false]);
+            expect(Convert.toArray('example')).toEqual(['example']);
+            expect(Convert.toArray(123)).toEqual([123]);
+        });
+
+        test('Должен оборачивать экземпляр класса в массив', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toArray(instance)).toEqual([instance]);
+        });
+    });
+
+    describe('Метод Convert.toAssoc', () => {
+        test('Должен возвращать пустой ассоциативный массив для null и undefined', () => {
+            expect(Convert.toAssoc(null)).toEqual({});
+            expect(Convert.toAssoc(undefined)).toEqual({});
+        });
+
+        test('Должен преобразовывать список в ассоциативный массив', () => {
+            const input = [1, 2, 3];
+            expect(Convert.toAssoc(input)).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+
+        test('Должен возвращать исходный ассоциативный массив, если он передан', () => {
+            const input = { key: 'value' };
+            expect(Convert.toAssoc(input)).toBe(input);
+        });
+
+        test('Должен возвращать ассоциативный массив с ключом 0 и переданным значением для примитивов', () => {
+            expect(Convert.toAssoc(true)).toEqual({ 0: true });
+            expect(Convert.toAssoc(false)).toEqual({ 0: false });
+            expect(Convert.toAssoc('example')).toEqual({ 0: 'example' });
+            expect(Convert.toAssoc(123)).toEqual({ 0: 123 });
+        });
+
+        test('Должен оборачивать экземпляр класса в ассоциативный массив с ключом 0', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toAssoc(instance)).toEqual({ 0: instance });
+        });
+    });
+
+    describe('Метод Convert.toBool', () => {
+        test('Должен возвращать false для пустого массива', () => {
+            expect(Convert.toBool([])).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого массива', () => {
+            expect(Convert.toBool([1, 2, 3])).toBe(true);
+        });
+
+        test('Должен возвращать false для пустого ассоциативного массива', () => {
+            expect(Convert.toBool({})).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого ассоциативного массива', () => {
+            expect(Convert.toBool({ key: 'value' })).toBe(true);
+        });
+
+        test('Должен возвращать true для строки', () => {
+            expect(Convert.toBool('example')).toBe(true);
+        });
+
+        test('Должен возвращать true для числа', () => {
+            expect(Convert.toBool(123)).toBe(true);
+        });
+
+        test('Должен возвращать false для null и undefined', () => {
+            expect(Convert.toBool(null)).toBe(false);
+            expect(Convert.toBool(undefined)).toBe(false);
+        });
+
+        test('Должен возвращать true для булевых значений', () => {
+            expect(Convert.toBool(true)).toBe(true);
+            expect(Convert.toBool(false)).toBe(false);
+        });
+
+        test('Должен возвращать true для экземпляров класса', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toBool(instance)).toBe(true);
+        });
+
+        test('Должен возвращать true для классов', () => {
+            class MyClass {}
+
+            expect(Convert.toBool(MyClass)).toBe(true);
+        });
+    });
+
+    describe('Метод Convert.toBoolean', () => {
+        test('Должен возвращать false для пустого массива', () => {
+            expect(Convert.toBoolean([])).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого массива', () => {
+            expect(Convert.toBoolean([1, 2, 3])).toBe(true);
+        });
+
+        test('Должен возвращать false для пустого ассоциативного массива', () => {
+            expect(Convert.toBoolean({})).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого ассоциативного массива', () => {
+            expect(Convert.toBoolean({ key: 'value' })).toBe(true);
+        });
+
+        test('Должен возвращать true для строки', () => {
+            expect(Convert.toBoolean('example')).toBe(true);
+        });
+
+        test('Должен возвращать true для числа', () => {
+            expect(Convert.toBoolean(123)).toBe(true);
+        });
+
+        test('Должен возвращать false для null и undefined', () => {
+            expect(Convert.toBoolean(null)).toBe(false);
+            expect(Convert.toBoolean(undefined)).toBe(false);
+        });
+
+        test('Должен возвращать true для булевых значений', () => {
+            expect(Convert.toBoolean(true)).toBe(true);
+            expect(Convert.toBoolean(false)).toBe(false);
+        });
+
+        test('Должен возвращать true для экземпляров класса', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toBoolean(instance)).toBe(true);
+        });
+
+        test('Должен возвращать true для классов', () => {
+            class MyClass {}
+
+            expect(Convert.toBoolean(MyClass)).toBe(true);
+        });
+    });
+
+    describe('Метод Convert.toFloat', () => {
+        test('Должен возвращать число с плавающей точкой для строки', () => {
+            expect(Convert.toFloat('123.45')).toBe(123.45);
+        });
+
+        test('Должен возвращать число с плавающей точкой для целого числа', () => {
+            expect(Convert.toFloat(123)).toBe(123.0);
+        });
+
+        test('Должен возвращать 1 для true и 0 для false', () => {
+            expect(Convert.toFloat(true)).toBe(1.0);
+            expect(Convert.toFloat(false)).toBe(0.0);
+        });
+
+        test('Должен возвращать 0 для null и undefined', () => {
+            expect(Convert.toFloat(null)).toBe(0.0);
+            expect(Convert.toFloat(undefined)).toBe(0.0);
+        });
+
+        test('Должен возвращать 0 для нечисловых строк', () => {
+            expect(Convert.toFloat('example')).toBe(0.0);
+        });
+    });
+
+    describe('Метод Convert.toInt', () => {
+        test('Должен возвращать целое число для строки', () => {
+            expect(Convert.toInt('123')).toBe(123);
+        });
+
+        test('Должен возвращать целое число для числа с плавающей точкой', () => {
+            expect(Convert.toInt(123.45)).toBe(123);
+        });
+
+        test('Должен возвращать 1 для true и 0 для false', () => {
+            expect(Convert.toInt(true)).toBe(1);
+            expect(Convert.toInt(false)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для null и undefined', () => {
+            expect(Convert.toInt(null)).toBe(0);
+            expect(Convert.toInt(undefined)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для нечисловых строк', () => {
+            expect(Convert.toInt('example')).toBe(0);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления', () => {
+            expect(Convert.toInt('10', 2)).toBe(2);
+            expect(Convert.toInt('A', 16)).toBe(10);
+            expect(Convert.toInt('7', 8)).toBe(7);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 2', () => {
+            expect(Convert.toInt('1010', 2)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 16', () => {
+            expect(Convert.toInt('A', 16)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 8', () => {
+            expect(Convert.toInt('7', 8)).toBe(7);
+        });
+
+        test('Должен выбрасывать исключение для неверного значения параметра base', () => {
+            expect(() => Convert.toInt('123', 'invalid')).toThrow(TypeError);
+        });
+    });
+
+    describe('Метод Convert.toInteger', () => {
+        test('Должен возвращать целое число для строки', () => {
+            expect(Convert.toInteger('123')).toBe(123);
+        });
+
+        test('Должен возвращать целое число для числа с плавающей точкой', () => {
+            expect(Convert.toInteger(123.45)).toBe(123);
+        });
+
+        test('Должен возвращать 1 для true и 0 для false', () => {
+            expect(Convert.toInteger(true)).toBe(1);
+            expect(Convert.toInteger(false)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для null и undefined', () => {
+            expect(Convert.toInteger(null)).toBe(0);
+            expect(Convert.toInteger(undefined)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для нечисловых строк', () => {
+            expect(Convert.toInteger('example')).toBe(0);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления', () => {
+            expect(Convert.toInteger('10', 2)).toBe(2);
+            expect(Convert.toInteger('A', 16)).toBe(10);
+            expect(Convert.toInteger('7', 8)).toBe(7);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 2', () => {
+            expect(Convert.toInteger('1010', 2)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 16', () => {
+            expect(Convert.toInteger('A', 16)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 8', () => {
+            expect(Convert.toInteger('7', 8)).toBe(7);
+        });
+
+        test('Должен выбрасывать исключение для неверного значения параметра base', () => {
+            expect(() => Convert.toInteger('123', 'invalid')).toThrow(TypeError);
+        });
+    });
+
+    describe('Метод Convert.toList', () => {
+        test('Должен возвращать пустой массив для null и undefined', () => {
+            expect(Convert.toList(null)).toEqual([]);
+            expect(Convert.toList(undefined)).toEqual([]);
+        });
+
+        test('Должен возвращать исходный массив, если он передан', () => {
+            const input = [1, 2, 3];
+            expect(Convert.toList(input)).toBe(input);
+        });
+
+        test('Должен возвращать массив значений объекта, если передан ассоциативный массив', () => {
+            const input = { key: 'value' };
+            expect(Convert.toList(input)).toEqual(['value']);
+        });
+
+        test('Должен возвращать массив, содержащий переданное значение для примитивов', () => {
+            expect(Convert.toList(true)).toEqual([true]);
+            expect(Convert.toList(false)).toEqual([false]);
+            expect(Convert.toList('example')).toEqual(['example']);
+            expect(Convert.toList(123)).toEqual([123]);
+        });
+    });
+
+    describe('Метод Convert.toObject', () => {
+        test('Должен возвращать объект без изменений', () => {
+            class MyClass {}
+            const obj = new MyClass();
+            expect(Convert.toObject(obj)).toBe(obj);
+        });
+
+        test('Должен возвращать новый экземпляр класса', () => {
+            class MyClass {}
+            const instance = Convert.toObject(MyClass);
+            expect(instance).toBeInstanceOf(MyClass);
+        });
+
+        test('Должен возвращать объект с элементами массива', () => {
+            const arr = [1, 2, 3];
+            const result = Convert.toObject(arr);
+            expect(result).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+
+        test('Должен возвращать объект с полем value для примитивов', () => {
+            expect(Convert.toObject('example')).toEqual({ value: 'example' });
+            expect(Convert.toObject(123)).toEqual({ value: 123 });
+            expect(Convert.toObject(true)).toEqual({ value: true });
+        });
+
+        test('Должен возвращать экземпляр анонимного класса для null и undefined', () => {
+            expect(Convert.toObject(null)).toBeInstanceOf(Object);
+            expect(Convert.toObject(undefined)).toBeInstanceOf(Object);
+        });
+    });
+
+    describe('Метод Convert.toString', () => {
+        test('Должен возвращать строку без изменений', () => {
+            expect(Convert.toString('example')).toBe('example');
+        });
+
+        test('Должен преобразовывать число в строку', () => {
+            expect(Convert.toString(123)).toBe('123');
+        });
+
+        test('Должен преобразовывать булевые значения в строку', () => {
+            expect(Convert.toString(true)).toBe('true');
+            expect(Convert.toString(false)).toBe('false');
+        });
+
+        test('Должен преобразовывать null и undefined в строку', () => {
+            expect(Convert.toString(null)).toBe('null');
+            expect(Convert.toString(undefined)).toBe('undefined');
+        });
+
+        test('Должен преобразовывать массив в строку', () => {
+            const arr = [1, 2, 3];
+            expect(Convert.toString(arr)).toBe('[\n    1,\n    2,\n    3,\n]');
+        });
+
+        test('Должен преобразовывать объект в строку', () => {
+            const obj = { key: 'value' };
+            expect(Convert.toString(obj)).toBe("{\n    key: 'value',\n}");
+        });
+
+        test('Должен преобразовывать функцию в строку', () => {
+            const func = function () {};
+            expect(Convert.toString(func)).toBe('function func() {}');
+        });
+
+        test('Должен преобразовывать символ в строку', () => {
+            const symbol = Symbol('example');
+            expect(Convert.toString(symbol)).toBe('Symbol(example)');
+        });
+
+        test('Должен преобразовывать BigInt в строку', () => {
+            const bigInt = BigInt(123);
+            expect(Convert.toString(bigInt)).toBe('123');
+        });
+
+        test('Должен преобразовывать класс в строку', () => {
+            class MyClass {
+                static test = 'test';
+            }
+            expect(Convert.toString(MyClass)).toBe('class MyClass {}');
+        });
+
+        test('Должен преобразовывать экземпляр класса в строку', () => {
+            class MyClass {}
+            const instance = new MyClass();
+            expect(Convert.toString(instance)).toBe('object MyClass');
+        });
+    });
+});