@rogolev/value 0.0.1

package/src/helpers/to_object.mjs

@@ -0,0 +1,94 @@
+import is_array from './is_array.mjs';
+import is_class from './is_class.mjs';
+import is_null from './is_null.mjs';
+import is_object from './is_object.mjs';
+import is_undefined from './is_undefined.mjs';
+
+/**
+ * Приводит значение переменной к объекту.
+ *
+ * ### Описание
+ *
+ * Функция `to_object` используется для преобразования различных типов данных в объект. Если значение уже является объектом, оно возвращается без изменений. Если значение является классом, возвращается новый экземпляр этого класса. Если значение является массивом, элементы массива копируются в новый объект. Для других значений создается объект с полем `value`, содержащим это значение.
+ *
+ * ### Параметры
+ *
+ * - `value` (any)
+ *      Переменная, значение которой необходимо привести к объекту.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает объект, соответствующий переданному значению.
+ *
+ * ### Примеры использования
+ *
+ * 1. Преобразование объекта:
+ *
+ *    ```js
+ *    class MyClass {}
+ *    const obj = new MyClass();
+ *    const result = to_object(obj);
+ *    // Результат: obj
+ *    ```
+ *
+ * 2. Преобразование класса:
+ *
+ *    ```js
+ *    class MyClass {}
+ *    const result = to_object(MyClass);
+ *    // Результат: экземпляр MyClass
+ *    ```
+ *
+ * 3. Преобразование null и undefined:
+ *
+ *    ```js
+ *    const result1 = to_object(null);
+ *    // Результат: экземпляр анонимного класса
+ *
+ *    const result2 = to_object(undefined);
+ *    // Результат: экземпляр анонимного класса
+ *    ```
+ *
+ * 4. Преобразование массива:
+ *
+ *    ```js
+ *    const arr = [1, 2, 3];
+ *    const result = to_object(arr);
+ *    // Результат: объект с элементами массива
+ *    ```
+ *
+ * 5. Преобразование других значений:
+ *
+ *    ```js
+ *    const result = to_object('example');
+ *    // Результат: объект с полем value, содержащим 'example'
+ *    ```
+ *
+ * @param {any} value Переменная, значение которой необходимо привести к объекту.
+ * @returns {object} Возвращает приведенное к объекту значение переменной `value`.
+ */
+export default function to_object(value) {
+    if (is_object(value)) {
+        return value;
+    }
+
+    if (is_class(value)) {
+        return new value();
+    }
+
+    const object = new (class {})();
+
+    if (is_null(value) || is_undefined(value)) {
+        return object;
+    }
+
+    if (is_array(value)) {
+        Object.assign(object, value);
+
+        return object;
+    }
+
+    object.value = value;
+
+    return object;
+}

package/src/helpers/to_string.mjs

@@ -0,0 +1,157 @@
+import is_array from './is_array.mjs';
+import is_class from './is_class.mjs';
+import is_function from './is_function.mjs';
+import is_object from './is_object.mjs';
+import is_string from './is_string.mjs';
+
+/**
+ * Приводит значение переменной к строке.
+ *
+ * ### Описание
+ *
+ * Функция `to_string` используется для преобразования различных типов данных в строку. Она обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое представление.
+ *
+ * ### Параметры
+ *
+ * - `value` (any)
+ *      Переменная, значение которой необходимо привести к строке.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает строку, соответствующую переданному значению.
+ *
+ * ### Примеры использования
+ *
+ * 1. Преобразование строки:
+ *
+ *    ```js
+ *    const result = to_string('example');
+ *    // Результат: 'example'
+ *    ```
+ *
+ * 2. Преобразование числа:
+ *
+ *    ```js
+ *    const result = to_string(123);
+ *    // Результат: '123'
+ *    ```
+ *
+ * 3. Преобразование булевых значений:
+ *
+ *    ```js
+ *    const result1 = to_string(true);
+ *    // Результат: 'true'
+ *
+ *    const result2 = to_string(false);
+ *    // Результат: 'false'
+ *    ```
+ *
+ * 4. Преобразование null и undefined:
+ *
+ *    ```js
+ *    const result1 = to_string(null);
+ *    // Результат: 'null'
+ *
+ *    const result2 = to_string(undefined);
+ *    // Результат: 'undefined'
+ *    ```
+ *
+ * 5. Преобразование массива:
+ *
+ *    ```js
+ *    const arr = [1, 2, 3];
+ *    const result = to_string(arr);
+ *    // Результат: '[\n    1,\n    2,\n    3,\n]'
+ *    ```
+ *
+ * 6. Преобразование объекта:
+ *
+ *    ```js
+ *    const obj = { key: 'value' };
+ *    const result = to_string(obj);
+ *    // Результат: '{\n    key: 'value',\n}'
+ *    ```
+ *
+ * 7. Преобразование функции:
+ *
+ *    ```js
+ *    const func = function() {};
+ *    const result = to_string(func);
+ *    // Результат: 'function func() {}'
+ *    ```
+ *
+ * 8. Преобразование символа:
+ *
+ *    ```js
+ *    const symbol = Symbol('example');
+ *    const result = to_string(symbol);
+ *    // Результат: 'Symbol(example)'
+ *    ```
+ *
+ * 9. Преобразование BigInt:
+ *
+ *    ```js
+ *    const bigInt = BigInt(123);
+ *    const result = to_string(bigInt);
+ *    // Результат: '123'
+ *    ```
+ *
+ * 10. Преобразование класса:
+ *
+ *    ```js
+ *    class MyClass {
+ *        static test = 'test';
+ *    }
+ *    const result = to_string(MyClass);
+ *    // Результат: 'class MyClass {}'
+ *    ```
+ *
+ * 11. Преобразование экземпляра класса:
+ *
+ *    ```js
+ *    class MyClass {}
+ *    const instance = new MyClass();
+ *    const result = to_string(instance);
+ *    // Результат: 'object MyClass'
+ *    ```
+ *
+ * @param {any} value Переменная, значение которой необходимо привести к строке.
+ * @returns {string} Возвращает приведенное к строке значение переменной `value`.
+ */
+export default function to_string(value) {
+    if (Array.isArray(value)) {
+        let string = '[';
+
+        for (const v of value) {
+            string += `\n    ${is_string(v) ? "'" : ''}${to_string(v).replace(/\n/g, '\n    ')}${is_string(v) ? "'" : ''},`;
+        }
+
+        return (string += string.length > 1 ? '\n]' : ']');
+    }
+
+    if (is_array(value)) {
+        let string = '{';
+
+        for (const [k, v] of Object.entries(value)) {
+            string += `\n    ${k}: ${is_string(v) ? "'" : ''}${to_string(v).replace(/\n/g, '\n    ')}${is_string(v) ? "'" : ''},`;
+        }
+
+        return (string += string.length > 1 ? '\n}' : '}');
+    }
+
+    if (is_class(value)) {
+        return `class ${value.name ? `${value.name} ` : ''}{}`;
+    }
+
+    if (is_object(value)) {
+        return value.toString() === '[object Object]' ?
+                `object ${Object.getPrototypeOf(value).constructor.name}`
+            :   value.toString();
+    }
+
+    if (is_function(value)) {
+        return `function ${value.name}() {}`;
+    }
+
+    return String(value);
+}

package/tests/helpers/array.test.mjs

@@ -0,0 +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' }]);
+    });
+});

package/tests/helpers/empty.test.mjs

@@ -0,0 +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);
+    });
+});

package/tests/helpers/gettype.test.mjs

@@ -0,0 +1,74 @@
+import { expect, test } from '@jest/globals';
+import { gettype } from '../../index.mjs';
+
+describe('Функция gettype', () => {
+    test('должна возвращать "null" для null', () => {
+        expect(gettype(null)).toBe('null');
+    });
+
+    test('должна возвращать "NaN" для NaN', () => {
+        expect(gettype(NaN)).toBe('NaN');
+    });
+
+    test('должна возвращать "undefined" для undefined', () => {
+        expect(gettype(undefined)).toBe('undefined');
+    });
+
+    test('должна возвращать "infinity" для Infinity и -Infinity', () => {
+        expect(gettype(Infinity)).toBe('infinity');
+        expect(gettype(-Infinity)).toBe('infinity');
+    });
+
+    test('должна возвращать "boolean" для логических значений', () => {
+        expect(gettype(true)).toBe('boolean');
+        expect(gettype(false)).toBe('boolean');
+    });
+
+    test('должна возвращать "integer" для целых чисел', () => {
+        expect(gettype(42)).toBe('integer');
+        expect(gettype(-42)).toBe('integer');
+        expect(gettype(0)).toBe('integer');
+    });
+
+    test('должна возвращать "bigint" для значений типа BigInt', () => {
+        expect(gettype(BigInt(123456))).toBe('bigint');
+        expect(gettype(BigInt(-123456))).toBe('bigint');
+    });
+
+    test('должна возвращать "float" для чисел с плавающей точкой', () => {
+        expect(gettype(3.14)).toBe('float');
+        expect(gettype(-0.99)).toBe('float');
+    });
+
+    test('должна возвращать "string" для строк', () => {
+        expect(gettype('hello')).toBe('string');
+        expect(gettype('')).toBe('string');
+    });
+
+    test('должна возвращать "symbol" для символов', () => {
+        expect(gettype(Symbol('symbol'))).toBe('symbol');
+    });
+
+    test('должна возвращать "class" для классов', () => {
+        class MyClass {}
+        expect(gettype(MyClass)).toBe('class');
+    });
+
+    test('должна возвращать "function" для функций', () => {
+        function func() {}
+        expect(gettype(func)).toBe('function');
+        expect(gettype(() => {})).toBe('function');
+    });
+
+    test('должна возвращать "array" для массивов', () => {
+        expect(gettype([])).toBe('array');
+        expect(gettype([1, 2, 3])).toBe('array');
+        expect(gettype({})).toBe('array');
+        expect(gettype({ foo: 'bar' })).toBe('array');
+    });
+
+    test('должна возвращать "object" для объектов', () => {
+        class MyClass {}
+        expect(gettype(new MyClass())).toBe('object');
+    });
+});