@rogolev/value 0.0.1

package/tests/helpers/is_float.test.mjs

@@ -0,0 +1,87 @@
+import { expect, test } from '@jest/globals';
+import { is_float } from '../../index.mjs';
+
+describe('Функция is_float', () => {
+    describe('Числа с плавающей точкой', () => {
+        test('должна возвращать true для положительных дробных чисел', () => {
+            expect(is_float(3.14)).toBe(true);
+        });
+
+        test('должна возвращать true для отрицательных дробных чисел', () => {
+            expect(is_float(-0.5)).toBe(true);
+        });
+
+        test('должна возвращать true для дробных чисел, полученных в результате вычислений', () => {
+            expect(is_float(0.1 + 0.2)).toBe(true);
+        });
+    });
+
+    describe('Целые числа', () => {
+        test('должна возвращать false для нуля', () => {
+            expect(is_float(0)).toBe(false);
+        });
+
+        test('должна возвращать false для положительных целых чисел', () => {
+            expect(is_float(42)).toBe(false);
+        });
+
+        test('должна возвращать false для отрицательных целых чисел', () => {
+            expect(is_float(-100)).toBe(false);
+        });
+    });
+
+    describe('Нечисловые значения', () => {
+        test('должна возвращать false для строки', () => {
+            expect(is_float('3.14')).toBe(false);
+        });
+
+        test('должна возвращать false для NaN', () => {
+            expect(is_float(NaN)).toBe(false);
+        });
+
+        test('должна возвращать false для null', () => {
+            expect(is_float(null)).toBe(false);
+        });
+
+        test('должна возвращать false для undefined', () => {
+            expect(is_float(undefined)).toBe(false);
+        });
+
+        test('должна возвращать false для булевых значений', () => {
+            expect(is_float(true)).toBe(false);
+            expect(is_float(false)).toBe(false);
+        });
+
+        test('должна возвращать false для объектов', () => {
+            expect(is_float({})).toBe(false);
+        });
+
+        test('должна возвращать false для массивов', () => {
+            expect(is_float([])).toBe(false);
+        });
+    });
+
+    describe('Специальные значения', () => {
+        test('должна возвращать false для Infinity', () => {
+            expect(is_float(Infinity)).toBe(false);
+        });
+
+        test('должна возвращать false для -Infinity', () => {
+            expect(is_float(-Infinity)).toBe(false);
+        });
+    });
+
+    describe('Проверка с использованием числовых строк', () => {
+        test('должна возвращать false для числовых строк', () => {
+            expect(is_float('3.14')).toBe(false);
+            expect(is_float('-0.5')).toBe(false);
+        });
+    });
+
+    describe('Проверка с использованием объектов Number', () => {
+        test('должна возвращать false для объектов Number', () => {
+            expect(is_float(new Number(3.14))).toBe(false);
+            expect(is_float(new Number(-0.5))).toBe(false);
+        });
+    });
+});

package/tests/helpers/is_function.test.mjs

@@ -0,0 +1,83 @@
+import { expect, test } from '@jest/globals';
+import { is_function } from '../../index.mjs';
+
+describe('Функция is_function', () => {
+    test('должна возвращать true для обычной функции', () => {
+        function example() {}
+        expect(is_function(example)).toBe(true);
+    });
+
+    test('должна возвращать false для класса', () => {
+        class MyClass {}
+        expect(is_function(MyClass)).toBe(false);
+    });
+
+    test('должна возвращать false для объектов', () => {
+        class MyClass {}
+        const obj = new MyClass();
+        expect(is_function(obj)).toBe(false);
+    });
+
+    test('должна возвращать false для массивов', () => {
+        expect(is_function([])).toBe(false);
+        expect(is_function({})).toBe(false);
+        expect(is_function(Object.create(null))).toBe(false);
+    });
+
+    test('должна возвращать false для примитивных типов', () => {
+        expect(is_function(42)).toBe(false);
+        expect(is_function('hello')).toBe(false);
+        expect(is_function(null)).toBe(false);
+        expect(is_function(undefined)).toBe(false);
+    });
+
+    test('должна возвращать true для стрелочных функций', () => {
+        expect(is_function(() => {})).toBe(true);
+    });
+
+    test('должна возвращать true для функции без строкового представления', () => {
+        const func = () => {};
+        func.toString = undefined;
+        expect(is_function(func)).toBe(true);
+    });
+
+    test('должна возвращать true для async функции', () => {
+        async function asyncFunc() {}
+        expect(is_function(asyncFunc)).toBe(true);
+    });
+
+    test('должна возвращать true для генератора', () => {
+        function* generatorFunc() {}
+        expect(is_function(generatorFunc)).toBe(true);
+    });
+
+    test('должна возвращать true для async генератора', () => {
+        async function* asyncGeneratorFunc() {}
+        expect(is_function(asyncGeneratorFunc)).toBe(true);
+    });
+
+    test('должна возвращать false для null', () => {
+        expect(is_function(null)).toBe(false);
+    });
+
+    test('должна возвращать false для undefined', () => {
+        expect(is_function(undefined)).toBe(false);
+    });
+
+    test('должна возвращать false для NaN', () => {
+        expect(is_function(NaN)).toBe(false);
+    });
+
+    test('должна возвращать false для символов', () => {
+        expect(is_function(Symbol('symbol'))).toBe(false);
+    });
+
+    test('должна возвращать false для объектов с методом toString', () => {
+        const obj = {
+            toString() {
+                return 'function';
+            },
+        };
+        expect(is_function(obj)).toBe(false);
+    });
+});

package/tests/helpers/is_infinity.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test } from '@jest/globals';
+import { is_infinity } from '../../index.mjs';
+
+describe('Функция is_infinity', () => {
+    test('должна возвращать true для Infinity', () => {
+        expect(is_infinity(Infinity)).toBe(true);
+    });
+
+    test('должна возвращать true для -Infinity', () => {
+        expect(is_infinity(-Infinity)).toBe(true);
+    });
+
+    test('должна возвращать false для чисел', () => {
+        expect(is_infinity(42)).toBe(false);
+        expect(is_infinity(3.14)).toBe(false);
+        expect(is_infinity(NaN)).toBe(false);
+    });
+
+    test('должна возвращать false для строк', () => {
+        expect(is_infinity('Infinity')).toBe(false);
+        expect(is_infinity('42')).toBe(false);
+        expect(is_infinity('')).toBe(false);
+    });
+
+    test('должна возвращать false для логических значений', () => {
+        expect(is_infinity(true)).toBe(false);
+        expect(is_infinity(false)).toBe(false);
+    });
+
+    test('должна возвращать false для null и undefined', () => {
+        expect(is_infinity(null)).toBe(false);
+        expect(is_infinity(undefined)).toBe(false);
+    });
+
+    test('должна возвращать false для объектов и массивов', () => {
+        expect(is_infinity({})).toBe(false);
+        expect(is_infinity([])).toBe(false);
+        expect(is_infinity({ foo: 42 })).toBe(false);
+        expect(is_infinity([1, 2, 3])).toBe(false);
+    });
+
+    test('должна возвращать false для функций', () => {
+        expect(is_infinity(() => {})).toBe(false);
+        expect(is_infinity(() => {})).toBe(false);
+    });
+});

package/tests/helpers/is_int.test.mjs

@@ -0,0 +1,45 @@
+import { expect, test } from '@jest/globals';
+import { is_int } from '../../index.mjs';
+
+describe('Функция is_int', () => {
+    test('Возвращает true для положительных целых чисел', () => {
+        expect(is_int(1)).toBe(true);
+        expect(is_int(100)).toBe(true);
+        expect(is_int(123456)).toBe(true);
+    });
+
+    test('Возвращает true для отрицательных целых чисел', () => {
+        expect(is_int(-1)).toBe(true);
+        expect(is_int(-100)).toBe(true);
+        expect(is_int(-123456)).toBe(true);
+    });
+
+    test('Возвращает true для нуля', () => {
+        expect(is_int(0)).toBe(true);
+    });
+
+    test('Возвращает false для чисел с плавающей точкой', () => {
+        expect(is_int(1.1)).toBe(false);
+        expect(is_int(-0.5)).toBe(false);
+        expect(is_int(3.14159)).toBe(false);
+    });
+
+    test('Возвращает false для значений не типа number', () => {
+        expect(is_int('42')).toBe(false); // строка
+        expect(is_int(true)).toBe(false); // логическое значение
+        expect(is_int(null)).toBe(false); // null
+        expect(is_int(undefined)).toBe(false); // undefined
+        expect(is_int({})).toBe(false); // объект
+        expect(is_int([])).toBe(false); // массив
+    });
+
+    test('Возвращает false для специальных числовых значений', () => {
+        expect(is_int(Infinity)).toBe(false); // бесконечность
+        expect(is_int(-Infinity)).toBe(false); // отрицательная бесконечность
+        expect(is_int(NaN)).toBe(false); // не число
+    });
+
+    test('Возвращает false для типа bigint', () => {
+        expect(is_int(BigInt(123456))).toBe(false);
+    });
+});

package/tests/helpers/is_integer.test.mjs

@@ -0,0 +1,64 @@
+import { expect, test } from '@jest/globals';
+import { is_integer } from '../../index.mjs';
+
+describe('Функция is_integer', () => {
+    test('должна возвращать true для положительных целых чисел', () => {
+        expect(is_integer(42)).toBe(true);
+        expect(is_integer(100)).toBe(true);
+        expect(is_integer(123456)).toBe(true);
+    });
+
+    test('должна возвращать true для отрицательных целых чисел', () => {
+        expect(is_integer(-42)).toBe(true);
+        expect(is_integer(-100)).toBe(true);
+        expect(is_integer(-123456)).toBe(true);
+    });
+
+    test('должна возвращать true для нуля', () => {
+        expect(is_integer(0)).toBe(true);
+    });
+
+    test('должна возвращать false для чисел с плавающей точкой', () => {
+        expect(is_integer(3.14)).toBe(false);
+        expect(is_integer(-0.99)).toBe(false);
+        expect(is_integer(0.1)).toBe(false);
+    });
+
+    test('должна возвращать false для специальных чисел', () => {
+        expect(is_integer(NaN)).toBe(false);
+        expect(is_integer(Infinity)).toBe(false);
+        expect(is_integer(-Infinity)).toBe(false);
+    });
+
+    test('должна возвращать false для строк', () => {
+        expect(is_integer('42')).toBe(false);
+        expect(is_integer('3.14')).toBe(false);
+        expect(is_integer('')).toBe(false);
+    });
+
+    test('должна возвращать false для логических значений', () => {
+        expect(is_integer(true)).toBe(false);
+        expect(is_integer(false)).toBe(false);
+    });
+
+    test('должна возвращать false для null и undefined', () => {
+        expect(is_integer(null)).toBe(false);
+        expect(is_integer(undefined)).toBe(false);
+    });
+
+    test('должна возвращать false для объектов и массивов', () => {
+        expect(is_integer({})).toBe(false);
+        expect(is_integer([])).toBe(false);
+        expect(is_integer({ foo: 42 })).toBe(false);
+        expect(is_integer([1, 2, 3])).toBe(false);
+    });
+
+    test('должна возвращать false для функций', () => {
+        expect(is_integer(() => {})).toBe(false);
+        expect(is_integer(() => {})).toBe(false);
+    });
+
+    test('должна возвращать false для типа bigint', () => {
+        expect(is_integer(BigInt(123456))).toBe(false);
+    });
+});

package/tests/helpers/is_list.test.mjs

@@ -0,0 +1,42 @@
+import { expect, test } from '@jest/globals';
+import { is_list } from '../../index.mjs';
+
+describe('Функция is_list', () => {
+    test('должна возвращать true для массивов', () => {
+        expect(is_list([])).toBe(true);
+        expect(is_list([1, 2, 3])).toBe(true);
+    });
+
+    test('должна возвращать false для ассоциативных массивов', () => {
+        expect(is_list({})).toBe(false);
+        expect(is_list({ foo: 'bar' })).toBe(false);
+    });
+
+    test('должна возвращать false для строк', () => {
+        expect(is_list('string')).toBe(false);
+    });
+
+    test('должна возвращать false для чисел', () => {
+        expect(is_list(42)).toBe(false);
+    });
+
+    test('должна возвращать false для null и undefined', () => {
+        expect(is_list(null)).toBe(false);
+        expect(is_list(undefined)).toBe(false);
+    });
+
+    test('должна возвращать false для логических значений', () => {
+        expect(is_list(true)).toBe(false);
+        expect(is_list(false)).toBe(false);
+    });
+
+    test('должна возвращать false для функций', () => {
+        function func() {}
+        expect(is_list(func)).toBe(false);
+        expect(is_list(() => {})).toBe(false);
+    });
+
+    test('должна возвращать false для символов', () => {
+        expect(is_list(Symbol('symbol'))).toBe(false);
+    });
+});

package/tests/helpers/is_nan.test.mjs

@@ -0,0 +1,43 @@
+import { expect, test } from '@jest/globals';
+import { is_nan } from '../../index.mjs';
+
+describe('Функция is_nan', () => {
+    test('должна возвращать true для NaN', () => {
+        expect(is_nan(NaN)).toBe(true);
+    });
+
+    test('должна возвращать false для чисел', () => {
+        expect(is_nan(42)).toBe(false);
+        expect(is_nan(3.14)).toBe(false);
+        expect(is_nan(Infinity)).toBe(false);
+        expect(is_nan(-Infinity)).toBe(false);
+    });
+
+    test('должна возвращать false для строк', () => {
+        expect(is_nan('42')).toBe(false);
+        expect(is_nan('NaN')).toBe(false);
+        expect(is_nan('')).toBe(false);
+    });
+
+    test('должна возвращать false для логических значений', () => {
+        expect(is_nan(true)).toBe(false);
+        expect(is_nan(false)).toBe(false);
+    });
+
+    test('должна возвращать false для null и undefined', () => {
+        expect(is_nan(null)).toBe(false);
+        expect(is_nan(undefined)).toBe(false);
+    });
+
+    test('должна возвращать false для объектов и массивов', () => {
+        expect(is_nan({})).toBe(false);
+        expect(is_nan([])).toBe(false);
+        expect(is_nan({ foo: 42 })).toBe(false);
+        expect(is_nan([1, 2, 3])).toBe(false);
+    });
+
+    test('должна возвращать false для функций', () => {
+        expect(is_nan(() => {})).toBe(false);
+        expect(is_nan(() => {})).toBe(false);
+    });
+});

package/tests/helpers/is_null.test.mjs

@@ -0,0 +1,17 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_null } from '../../index.mjs';
+
+describe('Функция is_null', () => {
+    test('Возвращает true для значения null', () => {
+        expect(is_null(null)).toBe(true);
+    });
+
+    test('Возвращает false для значений не типа null', () => {
+        expect(is_null(undefined)).toBe(false);
+        expect(is_null(0)).toBe(false);
+        expect(is_null('')).toBe(false);
+        expect(is_null(false)).toBe(false);
+        expect(is_null({})).toBe(false);
+        expect(is_null([])).toBe(false);
+    });
+});

package/tests/helpers/is_number.test.mjs

@@ -0,0 +1,25 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_number } from '../../index.mjs';
+
+describe('Функция is_number', () => {
+    test('Возвращает true для числовых значений', () => {
+        expect(is_number(42)).toBe(true);
+        expect(is_number(3.14)).toBe(true);
+        expect(is_number(-0.99)).toBe(true);
+    });
+
+    test('Возвращает false для специальных числовых значений', () => {
+        expect(is_number(NaN)).toBe(false);
+        expect(is_number(Infinity)).toBe(false);
+        expect(is_number(-Infinity)).toBe(false);
+    });
+
+    test('Возвращает false для значений не типа number', () => {
+        expect(is_number('42')).toBe(false); // строка
+        expect(is_number(true)).toBe(false); // логическое значение
+        expect(is_number(null)).toBe(false); // null
+        expect(is_number(undefined)).toBe(false); // undefined
+        expect(is_number({})).toBe(false); // объект
+        expect(is_number([])).toBe(false); // массив
+    });
+});

package/tests/helpers/is_numeric.test.mjs

@@ -0,0 +1,30 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_numeric } from '../../index.mjs';
+
+describe('Функция is_numeric', () => {
+    test('Возвращает true для числовых значений', () => {
+        expect(is_numeric(42)).toBe(true);
+        expect(is_numeric(3.14)).toBe(true);
+        expect(is_numeric(-0.99)).toBe(true);
+    });
+
+    test('Возвращает true для числовых строк', () => {
+        expect(is_numeric('42')).toBe(true);
+        expect(is_numeric('3.14')).toBe(true);
+        expect(is_numeric('-0.99')).toBe(true);
+    });
+
+    test('Возвращает false для специальных числовых значений', () => {
+        expect(is_numeric(NaN)).toBe(false);
+        expect(is_numeric(Infinity)).toBe(false);
+        expect(is_numeric(-Infinity)).toBe(false);
+    });
+
+    test('Возвращает false для значений не типа number или string', () => {
+        expect(is_numeric(true)).toBe(false); // логическое значение
+        expect(is_numeric(null)).toBe(false); // null
+        expect(is_numeric(undefined)).toBe(false); // undefined
+        expect(is_numeric({})).toBe(false); // объект
+        expect(is_numeric([])).toBe(false); // массив
+    });
+});

package/tests/helpers/is_object.test.mjs

@@ -0,0 +1,52 @@
+import { expect, test } from '@jest/globals';
+import { is_object } from '../../index.mjs';
+
+describe('Функция is_object', () => {
+    test('должна возвращать true для объектов, созданных с использованием классов', () => {
+        class MyClass {}
+        const myClassInstance = new MyClass();
+        expect(is_object(myClassInstance)).toBe(true);
+    });
+
+    test('должна возвращать false для классов', () => {
+        class MyClass {}
+        expect(is_object(MyClass)).toBe(false);
+    });
+
+    test('должна возвращать false для ассоциативных массивов', () => {
+        const obj = {};
+        expect(is_object(obj)).toBe(false);
+    });
+
+    test('должна возвращать false для массивов', () => {
+        const arr = [];
+        expect(is_object(arr)).toBe(false);
+    });
+
+    test('должна возвращать false для объектов, таких как Date', () => {
+        const date = new Date();
+        expect(is_object(date)).toBe(false);
+    });
+
+    test('должна возвращать false для null', () => {
+        expect(is_object(null)).toBe(false);
+    });
+
+    test('должна возвращать false для числа', () => {
+        expect(is_object(42)).toBe(false);
+    });
+
+    test('должна возвращать false для строки', () => {
+        expect(is_object('string')).toBe(false);
+    });
+
+    test('должна возвращать false для объектов, таких как Map', () => {
+        const map = new Map();
+        expect(is_object(map)).toBe(false);
+    });
+
+    test('должна возвращать false для объектов, созданных с Object.create(null)', () => {
+        const objNoProto = Object.create(null);
+        expect(is_object(objNoProto)).toBe(false);
+    });
+});

package/tests/helpers/is_scalar.test.mjs

@@ -0,0 +1,21 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_scalar } from '../../index.mjs';
+
+describe('Функция is_scalar', () => {
+    test('Возвращает true для скалярных значений', () => {
+        expect(is_scalar(true)).toBe(true);
+        expect(is_scalar(false)).toBe(true);
+        expect(is_scalar(42)).toBe(true);
+        expect(is_scalar(3.14)).toBe(true);
+        expect(is_scalar('hello')).toBe(true);
+        expect(is_scalar(Symbol('symbol'))).toBe(true);
+    });
+
+    test('Возвращает false для не скалярных значений', () => {
+        expect(is_scalar(null)).toBe(false);
+        expect(is_scalar(undefined)).toBe(false);
+        expect(is_scalar({})).toBe(false); // объект
+        expect(is_scalar([])).toBe(false); // массив
+        expect(is_scalar(() => {})).toBe(false); // функция
+    });
+});

package/tests/helpers/is_string.test.mjs

@@ -0,0 +1,20 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_string } from '../../index.mjs';
+
+describe('Функция is_string', () => {
+    test('Возвращает true для строковых значений', () => {
+        expect(is_string('hello')).toBe(true);
+        expect(is_string('')).toBe(true);
+        expect(is_string(`template string`)).toBe(true);
+    });
+
+    test('Возвращает false для значений других типов', () => {
+        expect(is_string(42)).toBe(false); // число
+        expect(is_string(true)).toBe(false); // логическое значение
+        expect(is_string(null)).toBe(false);
+        expect(is_string(undefined)).toBe(false);
+        expect(is_string({})).toBe(false); // объект
+        expect(is_string([])).toBe(false); // массив
+        expect(is_string(() => {})).toBe(false); // функция
+    });
+});

package/tests/helpers/is_symbol.test.mjs

@@ -0,0 +1,20 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_symbol } from '../../index.mjs';
+
+describe('Функция is_symbol', () => {
+    test('Возвращает true для символов', () => {
+        expect(is_symbol(Symbol('symbol'))).toBe(true);
+        expect(is_symbol(Symbol.iterator)).toBe(true);
+    });
+
+    test('Возвращает false для значений других типов', () => {
+        expect(is_symbol('hello')).toBe(false); // строка
+        expect(is_symbol(42)).toBe(false); // число
+        expect(is_symbol(true)).toBe(false); // логическое значение
+        expect(is_symbol(null)).toBe(false);
+        expect(is_symbol(undefined)).toBe(false);
+        expect(is_symbol({})).toBe(false); // объект
+        expect(is_symbol([])).toBe(false); // массив
+        expect(is_symbol(() => {})).toBe(false); // функция
+    });
+});

package/tests/helpers/is_undefined.test.mjs

@@ -0,0 +1,18 @@
+import { describe, test, expect } from '@jest/globals';
+import { is_undefined } from '../../index.mjs';
+
+describe('Функция is_undefined', () => {
+    test('Возвращает true для значения undefined', () => {
+        expect(is_undefined(undefined)).toBe(true);
+    });
+
+    test('Возвращает false для значений других типов', () => {
+        expect(is_undefined('hello')).toBe(false); // строка
+        expect(is_undefined(42)).toBe(false); // число
+        expect(is_undefined(true)).toBe(false); // логическое значение
+        expect(is_undefined(null)).toBe(false);
+        expect(is_undefined({})).toBe(false); // объект
+        expect(is_undefined([])).toBe(false); // массив
+        expect(is_undefined(() => {})).toBe(false); // функция
+    });
+});