@rogolev/value 0.0.1

package/tests/helpers/print.test.mjs

@@ -0,0 +1,62 @@
+import { expect, test, describe } from '@jest/globals';
+import { print } from '../../index.mjs';
+
+describe('Функция print', () => {
+    test('Должна возвращать строку для строки', () => {
+        expect(print('example', true)).toBe('"example"');
+    });
+
+    test('Должна возвращать строку для числа', () => {
+        expect(print(123, true)).toBe('123');
+        expect(print(123.45, true)).toBe('123.45');
+    });
+
+    test('Должна возвращать строку для булевых значений', () => {
+        expect(print(true, true)).toBe('true');
+        expect(print(false, true)).toBe('false');
+    });
+
+    test('Должна возвращать строку для null и undefined', () => {
+        expect(print(null, true)).toBe('null');
+        expect(print(undefined, true)).toBe('undefined');
+    });
+
+    test('Должна возвращать строку для массивов', () => {
+        const arr = [1, [2], 3];
+        expect(print(arr, true)).toBe(
+            '[\n    0: 1,\n    1: [\n        0: 2,\n    ],\n    2: 3,\n]',
+        );
+    });
+
+    test('Должна возвращать строку для ассоциативных массивов', () => {
+        const obj = { key: 'value' };
+        expect(print(obj, true)).toBe('{\n    key: "value",\n}');
+    });
+
+    test('Должна возвращать строку для функций', () => {
+        const func = function () {};
+        expect(print(func, true)).toBe('function func() {}');
+    });
+
+    test('Должна возвращать строку для символов', () => {
+        const symbol = Symbol('example');
+        expect(print(symbol, true)).toBe('Symbol(example)');
+    });
+
+    test('Должна возвращать строку для классов', () => {
+        class MyClass {
+            static test = 'test';
+        }
+        expect(print(MyClass, true)).toBe('class MyClass {\n    test = "test";\n}');
+    });
+
+    test('Должна возвращать строку для экземпляров классов', () => {
+        class MyClass {}
+        const instance = new MyClass();
+        expect(print(instance, true)).toBe('object MyClass {}');
+    });
+
+    test('Должна выбрасывать исключение для неверного значения параметра return_result', () => {
+        expect(() => print('example', 'invalid')).toThrow(TypeError);
+    });
+});

package/tests/helpers/print_type.test.mjs

@@ -0,0 +1,62 @@
+import { expect, test, describe } from '@jest/globals';
+import { print_type } from '../../index.mjs';
+
+describe('Функция print_type', () => {
+    test('Должна возвращать строку для строки', () => {
+        expect(print_type('example', true)).toBe('string(7) "example"');
+    });
+
+    test('Должна возвращать строку для числа', () => {
+        expect(print_type(123, true)).toBe('int(123)');
+        expect(print_type(123.45, true)).toBe('float(123.45)');
+    });
+
+    test('Должна возвращать строку для булевых значений', () => {
+        expect(print_type(true, true)).toBe('bool(true)');
+        expect(print_type(false, true)).toBe('bool(false)');
+    });
+
+    test('Должна возвращать строку для null и undefined', () => {
+        expect(print_type(null, true)).toBe('null');
+        expect(print_type(undefined, true)).toBe('undefined');
+    });
+
+    test('Должна возвращать строку для массивов', () => {
+        const arr = [1, [2], 3];
+        expect(print_type(arr, true)).toBe(
+            'array(3) [\n    0: int(1),\n    1: array(1) [\n        0: int(2),\n    ],\n    2: int(3),\n]',
+        );
+    });
+
+    test('Должна возвращать строку для ассоциативных массивов', () => {
+        const obj = { key: 'value' };
+        expect(print_type(obj, true)).toBe('array(1) {\n    key: string(5) "value",\n}');
+    });
+
+    test('Должна возвращать строку для функций', () => {
+        const func = function () {};
+        expect(print_type(func, true)).toBe('function func() {}');
+    });
+
+    test('Должна возвращать строку для символов', () => {
+        const symbol = Symbol('example');
+        expect(print_type(symbol, true)).toBe('Symbol(example)');
+    });
+
+    test('Должна возвращать строку для классов', () => {
+        class MyClass {
+            static test = 'test';
+        }
+        expect(print_type(MyClass, true)).toBe('class MyClass {\n    test = string(4) "test";\n}');
+    });
+
+    test('Должна возвращать строку для экземпляров классов', () => {
+        class MyClass {
+            test = 'test';
+        }
+        const instance = new MyClass();
+        expect(print_type(instance, true)).toBe(
+            'object(MyClass) (1) {\n    test = string(4) "test";\n}',
+        );
+    });
+});

package/tests/helpers/settype.test.mjs

@@ -0,0 +1,34 @@
+import { expect, test, describe } from '@jest/globals';
+import { settype } from '../../index.mjs';
+
+describe('Функция settype', () => {
+    test('Должна возвращать булевое значение', () => {
+        expect(settype('string', 'boolean')).toBe(true);
+        expect(settype('', 'boolean')).toBe(false);
+    });
+
+    test('Должна возвращать целое число', () => {
+        expect(settype('123', 'integer')).toBe(123);
+        expect(settype('123', 'int')).toBe(123);
+    });
+
+    test('Должна возвращать число с плавающей точкой', () => {
+        expect(settype('123.45', 'float')).toBe(123.45);
+    });
+
+    test('Должна возвращать строку', () => {
+        expect(settype(123, 'string')).toBe('123');
+    });
+
+    test('Должна возвращать массив', () => {
+        expect(settype('example', 'array')).toEqual(['example']);
+    });
+
+    test('Должна возвращать объект', () => {
+        expect(settype('example', 'object')).toEqual({ value: 'example' });
+    });
+
+    test('Должна возвращать исходное значение для неизвестного типа', () => {
+        expect(settype('example', 'unknown')).toBe('example');
+    });
+});

package/tests/helpers/to_array.test.mjs

@@ -0,0 +1,38 @@
+import { expect, test, describe } from '@jest/globals';
+import { to_array } from '../../index.mjs';
+
+describe('Функция to_array', () => {
+    test('Должна возвращать пустой массив для null и undefined', () => {
+        expect(to_array(null)).toEqual([]);
+        expect(to_array(undefined)).toEqual([]);
+    });
+
+    test('Должна возвращать исходный массив, если он передан', () => {
+        const input = [1, 2, 3];
+        expect(to_array(input)).toBe(input);
+    });
+
+    test('Должна возвращать ассоциативный массив без прототипа и с итератором Symbol.iterator при передаче объекта', () => {
+        const result = to_array({ key: 'value' });
+
+        expect(Object.getPrototypeOf(result)).toBeNull();
+
+        for (const entry of result) {
+            expect(entry).toEqual(['key', 'value']);
+        }
+    });
+
+    test('Должна возвращать массив с примитивными значениями', () => {
+        expect(to_array(true)).toEqual([true]);
+        expect(to_array(false)).toEqual([false]);
+        expect(to_array('example')).toEqual(['example']);
+        expect(to_array(123)).toEqual([123]);
+    });
+
+    test('Должна оборачивать экземпляр класса в массив', () => {
+        class MyClass {}
+
+        const instance = new MyClass();
+        expect(to_array(instance)).toEqual([instance]);
+    });
+});

package/tests/helpers/to_assoc.test.mjs

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

package/tests/helpers/to_bool.test.mjs

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

package/tests/helpers/to_boolean.test.mjs

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

package/tests/helpers/to_float.test.mjs

@@ -0,0 +1,26 @@
+import { expect, test, describe } from '@jest/globals';
+import { to_float } from '../../index.mjs';
+
+describe('Функция to_float', () => {
+    test('Должна возвращать число с плавающей точкой для строки', () => {
+        expect(to_float('123.45')).toBe(123.45);
+    });
+
+    test('Должна возвращать число с плавающей точкой для целого числа', () => {
+        expect(to_float(123)).toBe(123.0);
+    });
+
+    test('Должна возвращать 1 для true и 0 для false', () => {
+        expect(to_float(true)).toBe(1.0);
+        expect(to_float(false)).toBe(0.0);
+    });
+
+    test('Должна возвращать 0 для null и undefined', () => {
+        expect(to_float(null)).toBe(0.0);
+        expect(to_float(undefined)).toBe(0.0);
+    });
+
+    test('Должна возвращать 0 для нечисловых строк', () => {
+        expect(to_float('example')).toBe(0.0);
+    });
+});

package/tests/helpers/to_int.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { to_int } from '../../index.mjs';
+
+describe('Функция to_int', () => {
+    test('Должна возвращать целое число для строки', () => {
+        expect(to_int('123')).toBe(123);
+    });
+
+    test('Должна возвращать целое число для числа с плавающей точкой', () => {
+        expect(to_int(123.45)).toBe(123);
+    });
+
+    test('Должна возвращать 1 для true и 0 для false', () => {
+        expect(to_int(true)).toBe(1);
+        expect(to_int(false)).toBe(0);
+    });
+
+    test('Должна возвращать 0 для null и undefined', () => {
+        expect(to_int(null)).toBe(0);
+        expect(to_int(undefined)).toBe(0);
+    });
+
+    test('Должна возвращать 0 для нечисловых строк', () => {
+        expect(to_int('example')).toBe(0);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления', () => {
+        expect(to_int('10', 2)).toBe(2);
+        expect(to_int('A', 16)).toBe(10);
+        expect(to_int('7', 8)).toBe(7);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления 2', () => {
+        expect(to_int('1010', 2)).toBe(10);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления 16', () => {
+        expect(to_int('A', 16)).toBe(10);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления 8', () => {
+        expect(to_int('7', 8)).toBe(7);
+    });
+
+    test('Должна выбрасывать исключение для неверного значения параметра base', () => {
+        expect(() => to_int('123', 'invalid')).toThrow(TypeError);
+    });
+});

package/tests/helpers/to_integer.test.mjs

@@ -0,0 +1,48 @@
+import { expect, test, describe } from '@jest/globals';
+import { to_integer } from '../../index.mjs';
+
+describe('Функция to_integer', () => {
+    test('Должна возвращать целое число для строки', () => {
+        expect(to_integer('123')).toBe(123);
+    });
+
+    test('Должна возвращать целое число для числа с плавающей точкой', () => {
+        expect(to_integer(123.45)).toBe(123);
+    });
+
+    test('Должна возвращать 1 для true и 0 для false', () => {
+        expect(to_integer(true)).toBe(1);
+        expect(to_integer(false)).toBe(0);
+    });
+
+    test('Должна возвращать 0 для null и undefined', () => {
+        expect(to_integer(null)).toBe(0);
+        expect(to_integer(undefined)).toBe(0);
+    });
+
+    test('Должна возвращать 0 для нечисловых строк', () => {
+        expect(to_integer('example')).toBe(0);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления', () => {
+        expect(to_integer('10', 2)).toBe(2);
+        expect(to_integer('A', 16)).toBe(10);
+        expect(to_integer('7', 8)).toBe(7);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления 2', () => {
+        expect(to_integer('1010', 2)).toBe(10);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления 16', () => {
+        expect(to_integer('A', 16)).toBe(10);
+    });
+
+    test('Должна возвращать целое число для строки с основанием системы счисления 8', () => {
+        expect(to_integer('7', 8)).toBe(7);
+    });
+
+    test('Должна выбрасывать исключение для неверного значения параметра base', () => {
+        expect(() => to_integer('123', 'invalid')).toThrow(TypeError);
+    });
+});

package/tests/helpers/to_list.test.mjs

@@ -0,0 +1,32 @@
+import { expect, test, describe } from '@jest/globals';
+import { to_list } from '../../index.mjs';
+
+describe('Функция to_list', () => {
+    test('должна возвращать пустой массив для null и undefined', () => {
+        expect(to_list(null)).toEqual([]);
+        expect(to_list(undefined)).toEqual([]);
+    });
+
+    test('должна возвращать исходный массив, если он передан', () => {
+        const input = [1, 2, 3];
+        expect(to_list(input)).toBe(input);
+    });
+
+    test('должна возвращать массив значений объекта, если передан ассоциативный массив', () => {
+        const input = { key1: 'value1', key2: 'value2' };
+        expect(to_list(input)).toEqual(['value1', 'value2']);
+    });
+
+    test('должна возвращать массив с примитивными значениями', () => {
+        expect(to_list(true)).toEqual([true]);
+        expect(to_list(false)).toEqual([false]);
+        expect(to_list('example')).toEqual(['example']);
+        expect(to_list(123)).toEqual([123]);
+    });
+
+    test('должна оборачивать экземпляр класса в массив', () => {
+        class MyClass {}
+        const instance = new MyClass();
+        expect(to_list(instance)).toEqual([instance]);
+    });
+});

package/tests/helpers/to_object.test.mjs

@@ -0,0 +1,36 @@
+import { expect, test, describe } from '@jest/globals';
+import to_object from '../../src/helpers/to_object.mjs';
+
+describe('Функция to_object', () => {
+    test('Должна возвращать объект для объекта', () => {
+        class MyClass {}
+        const obj = new MyClass();
+        expect(to_object(obj)).toBe(obj);
+    });
+
+    test('Должна возвращать экземпляр класса для класса', () => {
+        class MyClass {}
+        const instance = to_object(MyClass);
+        expect(instance).toBeInstanceOf(MyClass);
+    });
+
+    test('Должна возвращать экземпляр анонимного класса для null и undefined', () => {
+        expect(Object.getPrototypeOf(to_object(null)).constructor.name).toBe('');
+        expect(Object.getPrototypeOf(to_object(undefined)).constructor.name).toBe('');
+    });
+
+    test('Должна возвращать объект с элементами массива для массива', () => {
+        const arr = [1, 2, 3];
+        const obj = to_object(arr);
+        expect(Object.getPrototypeOf(obj).constructor.name).toBe('');
+        expect(obj[0]).toBe(1);
+        expect(obj[1]).toBe(2);
+        expect(obj[2]).toBe(3);
+    });
+
+    test('Должна возвращать объект с полем value для других значений', () => {
+        const obj = to_object('example');
+        expect(Object.getPrototypeOf(obj).constructor.name).toBe('');
+        expect(obj.value).toBe('example');
+    });
+});

package/tests/helpers/to_string.test.mjs

@@ -0,0 +1,71 @@
+import { expect, test, describe } from '@jest/globals';
+import { to_string } from '../../index.mjs';
+
+describe('Функция to_string', () => {
+    test('Должна возвращать строку для строки', () => {
+        expect(to_string('example')).toBe('example');
+    });
+
+    test('Должна возвращать строку для числа', () => {
+        expect(to_string(123)).toBe('123');
+        expect(to_string(123.45)).toBe('123.45');
+    });
+
+    test('Должна возвращать строку для булевых значений', () => {
+        expect(to_string(true)).toBe('true');
+        expect(to_string(false)).toBe('false');
+    });
+
+    test('Должна возвращать строку для null и undefined', () => {
+        expect(to_string(null)).toBe('null');
+        expect(to_string(undefined)).toBe('undefined');
+    });
+
+    test('Должна возвращать строку для ассоциативных массивов', () => {
+        const obj = { key: 'value' };
+        expect(to_string(obj)).toBe("{\n    key: 'value',\n}");
+        expect(to_string({})).toBe('{}');
+    });
+
+    test('Должна возвращать строку для массивов', () => {
+        const arr = [1, [2], 3];
+        expect(to_string(arr)).toBe('[\n    1,\n    [\n        2,\n    ],\n    3,\n]');
+        expect(to_string([])).toBe('[]');
+    });
+
+    test('Должна возвращать строку для именованной функции', () => {
+        const func = function () {};
+        expect(to_string(func)).toBe('function func() {}');
+    });
+
+    test('Должна возвращать строку для безымянной функции', () => {
+        expect(to_string(() => {})).toBe('function () {}');
+    });
+
+    test('Должна возвращать строку для символов', () => {
+        const symbol = Symbol('example');
+        expect(to_string(symbol)).toBe('Symbol(example)');
+    });
+
+    test('Должна возвращать строку для BigInt', () => {
+        const bigInt = BigInt(123);
+        expect(to_string(bigInt)).toBe('123');
+    });
+
+    test('Должна возвращать строку для именованного класса', () => {
+        class MyClass {
+            static test = 'test';
+        }
+        expect(to_string(MyClass)).toBe('class MyClass {}');
+    });
+
+    test('Должна возвращать строку для безымянного класса', () => {
+        expect(to_string(class {})).toBe('class {}');
+    });
+
+    test('Должна возвращать строку для экземпляров классов', () => {
+        class MyClass {}
+        const instance = new MyClass();
+        expect(to_string(instance)).toBe('object MyClass');
+    });
+});