@rogolev/value 0.0.2 → 0.0.3

package/tests/classes/Value.test.mjs

@@ -0,0 +1,423 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { Value } from '../../index.mjs';
+
+describe('Класс Value', () => {
+    describe('Метод get', () => {
+        test('должен возвращать значение', () => {
+            const value = new Value('test');
+            expect(value.get()).toBe('test');
+        });
+    });
+
+    describe('Метод getType', () => {
+        test('должен возвращать тип значения', () => {
+            const value = new Value('test');
+            expect(value.getType()).toBe('string');
+        });
+    });
+
+    describe('Метод isEmpty', () => {
+        test('должен возвращать логическое значение', () => {
+            const value = new Value('test');
+            expect(value.isEmpty()).toBe(false);
+        });
+
+        test('должен возвращать true для пустых значений', () => {
+            const value1 = new Value(null);
+            const value2 = new Value(undefined);
+            const value3 = new Value('');
+            const value4 = new Value(0);
+            const value5 = new Value(false);
+            const value6 = new Value([]);
+            const value7 = new Value({});
+
+            expect(value1.isEmpty()).toBe(true);
+            expect(value2.isEmpty()).toBe(true);
+            expect(value3.isEmpty()).toBe(true);
+            expect(value4.isEmpty()).toBe(true);
+            expect(value5.isEmpty()).toBe(true);
+            expect(value6.isEmpty()).toBe(true);
+            expect(value7.isEmpty()).toBe(true);
+        });
+    });
+
+    describe('Метод print', () => {
+        test('должен распечатывать значение в консоль и возвращать текущий экземпляр класса Value', () => {
+            const logSpy = jest.spyOn(console, 'log');
+            const value = new Value('test');
+
+            expect(value.print()).toBe(value);
+            expect(logSpy).toHaveBeenCalledWith('"test"');
+        });
+    });
+
+    describe('Метод toPrint', () => {
+        test('должен возвращать распечатанное значение в виде экземпляра Value', () => {
+            const value = new Value('test');
+            const result = value.toPrint();
+
+            expect(result).toBeInstanceOf(Value);
+            expect(result.get()).toBe('"test"');
+        });
+    });
+
+    describe('Метод printType', () => {
+        test('должен распечатывать значение в консоль и возвращать текущий экземпляр класса Value', () => {
+            const logSpy = jest.spyOn(console, 'log');
+            const value = new Value('test');
+
+            expect(value.printType()).toBe(value);
+            expect(logSpy).toHaveBeenCalledWith('string(4) "test"');
+        });
+    });
+
+    describe('Метод toPrintType', () => {
+        test('должен возвращать распечатанное значение в виде экземпляра Value', () => {
+            const value = new Value('test');
+            const result = value.toPrintType();
+
+            expect(result).toBeInstanceOf(Value);
+            expect(result.get()).toBe('string(4) "test"');
+        });
+    });
+
+    describe('Метод isArray', () => {
+        test('должен проверять, является ли значение массивом', () => {
+            const value1 = new Value([1, 2, 3]);
+            const value2 = new Value({ foo: 'bar' });
+
+            expect(value1.isArray()).toBe(true);
+            expect(value2.isArray()).toBe(true);
+        });
+    });
+
+    describe('Метод isAssoc', () => {
+        test('должен проверять, является ли значение ассоциативным массивом', () => {
+            const value1 = new Value({ foo: 'bar' });
+            const value2 = new Value([1, 2, 3]);
+
+            expect(value1.isAssoc()).toBe(true);
+            expect(value2.isAssoc()).toBe(false);
+        });
+    });
+
+    describe('Метод isBigInt', () => {
+        test('должен проверять, является ли значение типом bigint', () => {
+            const value1 = new Value(BigInt(123456));
+            const value2 = new Value(123456);
+
+            expect(value1.isBigInt()).toBe(true);
+            expect(value2.isBigInt()).toBe(false);
+        });
+    });
+
+    describe('Метод isBool', () => {
+        test('должен проверять, является ли значение логическим типом', () => {
+            const value1 = new Value(true);
+            const value2 = new Value('true');
+
+            expect(value1.isBool()).toBe(true);
+            expect(value2.isBool()).toBe(false);
+        });
+    });
+
+    describe('Метод isBoolean', () => {
+        test('должен проверять, является ли значение логическим типом', () => {
+            const value1 = new Value(true);
+            const value2 = new Value('true');
+
+            expect(value1.isBoolean()).toBe(true);
+            expect(value2.isBoolean()).toBe(false);
+        });
+    });
+
+    describe('Метод isClass', () => {
+        test('должен проверять, является ли значение классом', () => {
+            class MyClass {}
+            function MyFunction() {}
+
+            const value1 = new Value(MyClass);
+            const value2 = new Value(MyFunction);
+
+            expect(value1.isClass()).toBe(true);
+            expect(value2.isClass()).toBe(false);
+        });
+    });
+
+    describe('Метод isFloat', () => {
+        test('должен проверять, является ли значение числом с плавающей точкой', () => {
+            const value1 = new Value(3.14);
+            const value2 = new Value(42);
+
+            expect(value1.isFloat()).toBe(true);
+            expect(value2.isFloat()).toBe(false);
+        });
+    });
+
+    describe('Метод isFunction', () => {
+        test('должен проверять, является ли значение функцией', () => {
+            function MyFunction() {}
+            class MyClass {}
+
+            const value1 = new Value(MyFunction);
+            const value2 = new Value(MyClass);
+
+            expect(value1.isFunction()).toBe(true);
+            expect(value2.isFunction()).toBe(false);
+        });
+    });
+
+    describe('Метод isInfinity', () => {
+        test('должен проверять, является ли значение бесконечностью', () => {
+            const value1 = new Value(Infinity);
+            const value2 = new Value(42);
+
+            expect(value1.isInfinity()).toBe(true);
+            expect(value2.isInfinity()).toBe(false);
+        });
+    });
+
+    describe('Метод isInt', () => {
+        test('должен проверять, является ли значение целым числом', () => {
+            const value1 = new Value(42);
+            const value2 = new Value(3.14);
+
+            expect(value1.isInt()).toBe(true);
+            expect(value2.isInt()).toBe(false);
+        });
+    });
+
+    describe('Метод isInteger', () => {
+        test('должен проверять, является ли значение целым числом', () => {
+            const value1 = new Value(42);
+            const value2 = new Value(3.14);
+
+            expect(value1.isInteger()).toBe(true);
+            expect(value2.isInteger()).toBe(false);
+        });
+    });
+
+    describe('Метод isList', () => {
+        test('должен проверять, является ли значение списком', () => {
+            const value1 = new Value([1, 2, 3]);
+            const value2 = new Value({ foo: 'bar' });
+
+            expect(value1.isList()).toBe(true);
+            expect(value2.isList()).toBe(false);
+        });
+    });
+
+    describe('Метод isNaN', () => {
+        test('должен проверять, является ли значение NaN', () => {
+            const value1 = new Value(NaN);
+            const value2 = new Value(42);
+
+            expect(value1.isNaN()).toBe(true);
+            expect(value2.isNaN()).toBe(false);
+        });
+    });
+
+    describe('Метод isNull', () => {
+        test('должен проверять, является ли значение null', () => {
+            const value1 = new Value(null);
+            const value2 = new Value(undefined);
+
+            expect(value1.isNull()).toBe(true);
+            expect(value2.isNull()).toBe(false);
+        });
+    });
+
+    describe('Метод isNumber', () => {
+        test('должен проверять, является ли значение числом', () => {
+            const value1 = new Value(42);
+            const value2 = new Value('42');
+
+            expect(value1.isNumber()).toBe(true);
+            expect(value2.isNumber()).toBe(false);
+        });
+    });
+
+    describe('Метод isNumeric', () => {
+        test('должен проверять, является ли значение числом или числовой строкой', () => {
+            const value1 = new Value(42);
+            const value2 = new Value('42');
+            const value3 = new Value('hello');
+
+            expect(value1.isNumeric()).toBe(true);
+            expect(value2.isNumeric()).toBe(true);
+            expect(value3.isNumeric()).toBe(false);
+        });
+    });
+
+    describe('Метод isObject', () => {
+        test('должен проверять, является ли значение объектом', () => {
+            const value1 = new Value(new (class {})());
+            const value2 = new Value(42);
+
+            expect(value1.isObject()).toBe(true);
+            expect(value2.isObject()).toBe(false);
+        });
+    });
+
+    describe('Метод isScalar', () => {
+        test('должен проверять, является ли значение скалярным', () => {
+            const value1 = new Value(42);
+            const value2 = new Value({});
+            const value3 = new Value('hello');
+
+            expect(value1.isScalar()).toBe(true);
+            expect(value2.isScalar()).toBe(false);
+            expect(value3.isScalar()).toBe(true);
+        });
+    });
+
+    describe('Метод isString', () => {
+        test('должен проверять, является ли значение строкой', () => {
+            const value1 = new Value('hello');
+            const value2 = new Value(42);
+
+            expect(value1.isString()).toBe(true);
+            expect(value2.isString()).toBe(false);
+        });
+    });
+
+    describe('Метод isSymbol', () => {
+        test('должен проверять, является ли значение символом', () => {
+            const value1 = new Value(Symbol('symbol'));
+            const value2 = new Value('symbol');
+
+            expect(value1.isSymbol()).toBe(true);
+            expect(value2.isSymbol()).toBe(false);
+        });
+    });
+
+    describe('Метод isUndefined', () => {
+        test('должен проверять, является ли значение undefined', () => {
+            const value1 = new Value(undefined);
+            const value2 = new Value(null);
+
+            expect(value1.isUndefined()).toBe(true);
+            expect(value2.isUndefined()).toBe(false);
+        });
+    });
+
+    describe('Метод toArray', () => {
+        test('должен преобразовывать значение в массив', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value({ key: 'value' });
+
+            expect(value1.toArray().get()).toEqual(['test']);
+            expect(value2.toArray().get()).toEqual([123]);
+            expect(value3.toArray().get()).toEqual({ key: 'value' });
+        });
+    });
+
+    describe('Метод toAssoc', () => {
+        test('должен преобразовывать значение в ассоциативный массив', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value([1, 2, 3]);
+
+            expect(value1.toAssoc().get()).toEqual({ 0: 'test' });
+            expect(value2.toAssoc().get()).toEqual({ 0: 123 });
+            expect(value3.toAssoc().get()).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+    });
+
+    describe('Метод toBool', () => {
+        test('должен преобразовывать значение в логическое значение', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(0);
+            const value3 = new Value(null);
+
+            expect(value1.toBool().get()).toBe(true);
+            expect(value2.toBool().get()).toBe(false);
+            expect(value3.toBool().get()).toBe(false);
+        });
+    });
+
+    describe('Метод toBoolean', () => {
+        test('должен преобразовывать значение в логическое значение', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(0);
+            const value3 = new Value(null);
+
+            expect(value1.toBoolean().get()).toBe(true);
+            expect(value2.toBoolean().get()).toBe(false);
+            expect(value3.toBoolean().get()).toBe(false);
+        });
+    });
+
+    describe('Метод toFloat', () => {
+        test('должен преобразовывать значение в число с плавающей точкой', () => {
+            const value1 = new Value('123.45');
+            const value2 = new Value(123);
+            const value3 = new Value('test');
+
+            expect(value1.toFloat().get()).toBe(123.45);
+            expect(value2.toFloat().get()).toBe(123.0);
+            expect(value3.toFloat().get()).toBe(0.0);
+        });
+    });
+
+    describe('Метод toInt', () => {
+        test('должен преобразовывать значение в целое число', () => {
+            const value1 = new Value('123');
+            const value2 = new Value(123.45);
+            const value3 = new Value('test');
+
+            expect(value1.toInt().get()).toBe(123);
+            expect(value2.toInt().get()).toBe(123);
+            expect(value3.toInt().get()).toBe(0);
+        });
+    });
+
+    describe('Метод toInteger', () => {
+        test('должен преобразовывать значение в целое число', () => {
+            const value1 = new Value('123');
+            const value2 = new Value(123.45);
+            const value3 = new Value('test');
+
+            expect(value1.toInteger().get()).toBe(123);
+            expect(value2.toInteger().get()).toBe(123);
+            expect(value3.toInteger().get()).toBe(0);
+        });
+    });
+
+    describe('Метод toList', () => {
+        test('должен преобразовывать значение в список', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value({ key: 'value' });
+
+            expect(value1.toList().get()).toEqual(['test']);
+            expect(value2.toList().get()).toEqual([123]);
+            expect(value3.toList().get()).toEqual(['value']);
+        });
+    });
+
+    describe('Метод toObject', () => {
+        test('должен преобразовывать значение в объект', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value([1, 2, 3]);
+
+            expect(value1.toObject().get()).toEqual({ value: 'test' });
+            expect(value2.toObject().get()).toEqual({ value: 123 });
+            expect(value3.toObject().get()).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+    });
+
+    describe('Метод toString', () => {
+        test('должен преобразовывать значение в строку', () => {
+            const value1 = new Value(123);
+            const value2 = new Value(true);
+            const value3 = new Value({ key: 'value' });
+
+            expect(value1.toString().get()).toBe('123');
+            expect(value2.toString().get()).toBe('true');
+            expect(value3.toString().get()).toBe("{\n    key: 'value',\n}");
+        });
+    });
+});

package/tests/constants.test.mjs

@@ -0,0 +1,75 @@
+import { describe, test, expect } from '@jest/globals';
+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 '../index.mjs';
+
+describe('Константы', () => {
+    test('TYPE_NULL должно быть "null"', () => {
+        expect(TYPE_NULL).toBe('null');
+    });
+
+    test('TYPE_NAN должно быть "NaN"', () => {
+        expect(TYPE_NAN).toBe('NaN');
+    });
+
+    test('TYPE_UNDEFINED должно быть "undefined"', () => {
+        expect(TYPE_UNDEFINED).toBe('undefined');
+    });
+
+    test('TYPE_INFINITY должно быть "infinity"', () => {
+        expect(TYPE_INFINITY).toBe('infinity');
+    });
+
+    test('TYPE_BOOLEAN должно быть "boolean"', () => {
+        expect(TYPE_BOOLEAN).toBe('boolean');
+    });
+
+    test('TYPE_INTEGER должно быть "integer"', () => {
+        expect(TYPE_INTEGER).toBe('integer');
+    });
+
+    test('TYPE_BIGINT должно быть "bigint"', () => {
+        expect(TYPE_BIGINT).toBe('bigint');
+    });
+
+    test('TYPE_FLOAT должно быть "float"', () => {
+        expect(TYPE_FLOAT).toBe('float');
+    });
+
+    test('TYPE_STRING должно быть "string"', () => {
+        expect(TYPE_STRING).toBe('string');
+    });
+
+    test('TYPE_SYMBOL должно быть "symbol"', () => {
+        expect(TYPE_SYMBOL).toBe('symbol');
+    });
+
+    test('TYPE_CLASS должно быть "class"', () => {
+        expect(TYPE_CLASS).toBe('class');
+    });
+
+    test('TYPE_FUNCTION должно быть "function"', () => {
+        expect(TYPE_FUNCTION).toBe('function');
+    });
+
+    test('TYPE_ARRAY должно быть "array"', () => {
+        expect(TYPE_ARRAY).toBe('array');
+    });
+
+    test('TYPE_OBJECT должно быть "object"', () => {
+        expect(TYPE_OBJECT).toBe('object');
+    });
+});

package/tests/helpers/array.test.mjs

@@ -1,58 +1,58 @@
-import { expect, test, describe } from '@jest/globals';
-import { array } from '../../index.mjs';
-
-describe('Функция array', () => {
-    test('Должна возвращать массив с единственным элементом, если передан один массив', () => {
-        const input = [1, 2, 3];
-        const result = array(input);
-        expect(result).toEqual([1, 2, 3]);
-    });
-
-    test('Должна добавлять элементы в массив, если передано несколько значений', () => {
-        const result = array(1, [2, 3], { a: 10, b: 20 });
-        expect(result).toEqual([1, [2, 3], { a: 10, b: 20 }]);
-    });
-
-    test('Должна обрабатывать ассоциативные массивы (объекты с ключами и значениями)', () => {
-        const assoc = { key1: 'value1', key2: 'value2' };
-        const result = array(assoc);
-        expect(result).toEqual(assoc); // Элемент должен быть объектом
-        expect(Object.getPrototypeOf(result)).toBeNull(); // Прототип должен быть null
-    });
-
-    test('Должна создавать итератор для ассоциативного массива', () => {
-        const assoc = { key: 'value', anotherKey: 'anotherValue' };
-        const result = array(assoc);
-
-        const iteratorOutput = [];
-        for (const [key, value] of result) {
-            iteratorOutput.push([key, value]);
-        }
-
-        expect(iteratorOutput).toEqual([
-            ['key', 'value'],
-            ['anotherKey', 'anotherValue'],
-        ]);
-    });
-
-    test('Должна возвращать исходный массив, если он передан как единственный аргумент', () => {
-        const nestedArray = [1, 2, 3];
-        const result = array(nestedArray);
-        expect(result).toBe(nestedArray); // Массив должен быть возвращен напрямую
-    });
-
-    test('Должна работать с примитивными значениями', () => {
-        const result = array(42, 'test', true, null);
-        expect(result).toEqual([42, 'test', true, null]);
-    });
-
-    test('Должна возвращать массив, если передано несколько различных типов', () => {
-        const result = array(1, 'text', [2, 3], { foo: 'bar' });
-        expect(result).toEqual([1, 'text', [2, 3], { foo: 'bar' }]);
-    });
-
-    test('Должна возвращать массив с объектами и ассоциативными массивами', () => {
-        const result = array({ key1: 'value1' }, [1, 2], { key2: 'value2' });
-        expect(result).toEqual([{ key1: 'value1' }, [1, 2], { key2: 'value2' }]);
-    });
-});
+import { expect, test, describe } from '@jest/globals';
+import { array } from '../../index.mjs';
+
+describe('Функция array', () => {
+    test('Должна возвращать массив с единственным элементом, если передан один массив', () => {
+        const input = [1, 2, 3];
+        const result = array(input);
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('Должна добавлять элементы в массив, если передано несколько значений', () => {
+        const result = array(1, [2, 3], { a: 10, b: 20 });
+        expect(result).toEqual([1, [2, 3], { a: 10, b: 20 }]);
+    });
+
+    test('Должна обрабатывать ассоциативные массивы (объекты с ключами и значениями)', () => {
+        const assoc = { key1: 'value1', key2: 'value2' };
+        const result = array(assoc);
+        expect(result).toEqual(assoc); // Элемент должен быть объектом
+        expect(Object.getPrototypeOf(result)).toBeNull(); // Прототип должен быть null
+    });
+
+    test('Должна создавать итератор для ассоциативного массива', () => {
+        const assoc = { key: 'value', anotherKey: 'anotherValue' };
+        const result = array(assoc);
+
+        const iteratorOutput = [];
+        for (const [key, value] of result) {
+            iteratorOutput.push([key, value]);
+        }
+
+        expect(iteratorOutput).toEqual([
+            ['key', 'value'],
+            ['anotherKey', 'anotherValue'],
+        ]);
+    });
+
+    test('Должна возвращать исходный массив, если он передан как единственный аргумент', () => {
+        const nestedArray = [1, 2, 3];
+        const result = array(nestedArray);
+        expect(result).toBe(nestedArray); // Массив должен быть возвращен напрямую
+    });
+
+    test('Должна работать с примитивными значениями', () => {
+        const result = array(42, 'test', true, null);
+        expect(result).toEqual([42, 'test', true, null]);
+    });
+
+    test('Должна возвращать массив, если передано несколько различных типов', () => {
+        const result = array(1, 'text', [2, 3], { foo: 'bar' });
+        expect(result).toEqual([1, 'text', [2, 3], { foo: 'bar' }]);
+    });
+
+    test('Должна возвращать массив с объектами и ассоциативными массивами', () => {
+        const result = array({ key1: 'value1' }, [1, 2], { key2: 'value2' });
+        expect(result).toEqual([{ key1: 'value1' }, [1, 2], { key2: 'value2' }]);
+    });
+});

package/tests/helpers/empty.test.mjs

@@ -1,22 +1,22 @@
-import { expect, test, describe } from '@jest/globals';
-import { empty } from '../../index.mjs';
-
-describe('Функция empty', () => {
-    test('Должна возвращать true для пустых значений', () => {
-        expect(empty(null)).toBe(true);
-        expect(empty(undefined)).toBe(true);
-        expect(empty('')).toBe(true);
-        expect(empty(0)).toBe(true);
-        expect(empty(false)).toBe(true);
-        expect(empty([])).toBe(true);
-        expect(empty({})).toBe(true);
-    });
-
-    test('Должна возвращать false для непустых значений', () => {
-        expect(empty('example')).toBe(false);
-        expect(empty(123)).toBe(false);
-        expect(empty(true)).toBe(false);
-        expect(empty([1, 2, 3])).toBe(false);
-        expect(empty({ key: 'value' })).toBe(false);
-    });
-});
+import { expect, test, describe } from '@jest/globals';
+import { empty } from '../../index.mjs';
+
+describe('Функция empty', () => {
+    test('Должна возвращать true для пустых значений', () => {
+        expect(empty(null)).toBe(true);
+        expect(empty(undefined)).toBe(true);
+        expect(empty('')).toBe(true);
+        expect(empty(0)).toBe(true);
+        expect(empty(false)).toBe(true);
+        expect(empty([])).toBe(true);
+        expect(empty({})).toBe(true);
+    });
+
+    test('Должна возвращать false для непустых значений', () => {
+        expect(empty('example')).toBe(false);
+        expect(empty(123)).toBe(false);
+        expect(empty(true)).toBe(false);
+        expect(empty([1, 2, 3])).toBe(false);
+        expect(empty({ key: 'value' })).toBe(false);
+    });
+});