@rogolev/value 0.0.3 → 0.0.4

package/tests/helpers/array/natsort.test.mjs

@@ -0,0 +1,71 @@
+import { expect, test, describe } from '@jest/globals';
+import { natsort } from '../../../index.mjs';
+
+describe('Функция natsort', () => {
+    test('Должна корректно сортировать обычный массив', () => {
+        const array = [10, 2, 30, 4];
+        const result = natsort(array);
+        expect(result).toEqual([2, 4, 10, 30]);
+    });
+
+    test('Должна корректно сортировать ассоциативный массив', () => {
+        const array = { a: 10, b: 2, c: 30, d: 4 };
+        const result = natsort(array);
+        expect(result).toEqual([
+            ['b', 2],
+            ['d', 4],
+            ['a', 10],
+            ['c', 30],
+        ]);
+    });
+
+    test('Должна корректно сортировать массив с использованием функции getter', () => {
+        const array = [{ value: 10 }, { value: 2 }, { value: 30 }, { value: 4 }];
+        const result = natsort(array, (entry) => entry[1].value);
+        expect(result).toEqual([{ value: 2 }, { value: 4 }, { value: 10 }, { value: 30 }]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр getter не является функцией', () => {
+        const array = [10, 2, 30, 4];
+        expect(() => natsort(array, 'not a function')).toThrow(TypeError);
+        expect(() => natsort(array, 'not a function')).toThrow(
+            'Параметр "getter" должен быть функцией.',
+        );
+    });
+
+    test('Должна корректно сортировать массив строк', () => {
+        const array = ['apple', 'banana', 'cherry', 'date'];
+        const result = natsort(array);
+        expect(result).toEqual(['apple', 'banana', 'cherry', 'date']);
+    });
+
+    test('Должна корректно сортировать массив строк с числовыми значениями', () => {
+        const array = ['10', '2', '30', '4'];
+        const result = natsort(array);
+        expect(result).toEqual(['2', '4', '10', '30']);
+    });
+
+    test('Должна корректно сортировать массив строк с ведущими нулями', () => {
+        const array = ['0010', '010', '10', '001'];
+        const result = natsort(array);
+        expect(result).toEqual(['001', '0010', '010', '10']);
+    });
+
+    test('Должна корректно сортировать массив строк с пробелами', () => {
+        const array = [' 10', '10', ' 2', '2'];
+        const result = natsort(array);
+        expect(result).toEqual([' 2', '2', ' 10', '10']);
+    });
+
+    test('Должна корректно сортировать массив строк с буквами и числами', () => {
+        const array = ['a10', 'a2', 'b10', 'b2'];
+        const result = natsort(array);
+        expect(result).toEqual(['a2', 'a10', 'b2', 'b10']);
+    });
+
+    test('Должна корректно сортировать массив строк с разными символами', () => {
+        const array = ['10-', '10+', '10*', '10/'];
+        const result = natsort(array);
+        expect(result).toEqual(['10*', '10+', '10-', '10/']);
+    });
+});

package/tests/helpers/array/range.test.mjs

@@ -0,0 +1,51 @@
+import { expect, test, describe } from '@jest/globals';
+import { range } from '../../../index.mjs';
+
+describe('Функция range', () => {
+    test('Должна генерировать числовой диапазон', () => {
+        const result = range(1, 5);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна генерировать числовой диапазон с отрицательным шагом', () => {
+        const result = range(5, 1, -1);
+        expect(result).toEqual([5, 4, 3, 2, 1]);
+    });
+
+    test('Должна генерировать диапазон строк', () => {
+        const result = range('a', 'e');
+        expect(result).toEqual(['a', 'b', 'c', 'd', 'e']);
+    });
+
+    test('Должна обрабатывать значения с преобразованием типов', () => {
+        const result = range('1', 5);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "start" имеет неверный тип', () => {
+        expect(() => range({}, 5)).toThrow(TypeError);
+        expect(() => range({}, 5)).toThrow('Параметр "start" должен быть строкой или числом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "end" имеет неверный тип', () => {
+        expect(() => range(1, {})).toThrow(TypeError);
+        expect(() => range(1, {})).toThrow('Параметр "end" должен быть строкой или числом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "step" имеет неверный тип', () => {
+        expect(() => range(1, 5, 'a')).toThrow(TypeError);
+        expect(() => range(1, 5, 'a')).toThrow('Параметр "step" должен быть числом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "step" равен нулю', () => {
+        expect(() => range(1, 5, 0)).toThrow(TypeError);
+        expect(() => range(1, 5, 0)).toThrow('Параметр "step" не может быть равен нулю.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "step" отрицательный при start < end', () => {
+        expect(() => range(1, 5, -1)).toThrow(TypeError);
+        expect(() => range(1, 5, -1)).toThrow(
+            'Параметр "step" должен быть больше нуля при start <= end.',
+        );
+    });
+});

package/tests/helpers/array/shuffle.test.mjs

@@ -0,0 +1,42 @@
+import { expect, test, describe } from '@jest/globals';
+import { shuffle } from '../../../index.mjs';
+
+describe('Функция shuffle', () => {
+    test('Должна перемешивать элементы обычного массива', () => {
+        const array = [1, 2, 3, 4, 5];
+        const result = shuffle(array);
+        expect(result).toHaveLength(array.length);
+        expect(result).toEqual(expect.arrayContaining(array));
+        expect(result).not.toEqual(array); // Маловероятно, что массив останется в том же порядке
+    });
+
+    test('Должна перемешивать элементы ассоциативного массива', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = shuffle(array);
+        expect(result).toHaveLength(Object.keys(array).length);
+        expect(result).toEqual(
+            expect.arrayContaining([
+                ['a', 1],
+                ['b', 2],
+                ['c', 3],
+            ]),
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => shuffle('not an array')).toThrow(TypeError);
+        expect(() => shuffle('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+
+    test('Должна возвращать пустой массив, если исходный массив пуст', () => {
+        const array = [];
+        const result = shuffle(array);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна корректно перемешивать массив с одним элементом', () => {
+        const array = [1];
+        const result = shuffle(array);
+        expect(result).toEqual([1]);
+    });
+});

package/tests/helpers/array/sort.test.mjs

@@ -0,0 +1,60 @@
+import { expect, test, describe } from '@jest/globals';
+import { sort } from '../../../index.mjs';
+
+describe('Функция sort', () => {
+    test('Должна сортировать элементы обычного массива по умолчанию', () => {
+        const array = [5, 3, 1, 4, 2];
+        const result = sort(array);
+        expect(result).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    test('Должна сортировать элементы ассоциативного массива по умолчанию', () => {
+        const array = { a: 3, b: 1, c: 2 };
+        const result = sort(array);
+        expect(result).toEqual([
+            ['b', 1],
+            ['c', 2],
+            ['a', 3],
+        ]);
+    });
+
+    test('Должна сортировать элементы обычного массива с использованием пользовательской функции сравнения', () => {
+        const array = [5, 3, 1, 4, 2];
+        const result = sort(array, (a, b) => b[1] - a[1]);
+        expect(result).toEqual([5, 4, 3, 2, 1]);
+    });
+
+    test('Должна сортировать элементы ассоциативного массива с использованием пользовательской функции сравнения', () => {
+        const array = { a: 3, b: 1, c: 2 };
+        const result = sort(array, (a, b) => b[1] - a[1]);
+        expect(result).toEqual([
+            ['a', 3],
+            ['c', 2],
+            ['b', 1],
+        ]);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр не является массивом', () => {
+        expect(() => sort('not an array')).toThrow(TypeError);
+        expect(() => sort('not an array')).toThrow('Параметр "arr" должен быть массивом.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр compare_func не является функцией', () => {
+        expect(() => sort([1, 2, 3], 'not a function')).toThrow(TypeError);
+        expect(() => sort([1, 2, 3], 'not a function')).toThrow(
+            'Параметр "compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна корректно сортировать пустой массив', () => {
+        const array = [];
+        const result = sort(array);
+        expect(result).toEqual([]);
+    });
+
+    test('Должна корректно сортировать массив с одним элементом', () => {
+        const array = [1];
+        const result = sort(array);
+        expect(result).toEqual([1]);
+    });
+});

package/tests/helpers/is_char.test.mjs

@@ -0,0 +1,40 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_char } from '../../index.mjs';
+
+describe('Функция is_char', () => {
+    test('Должна возвращать true для одиночного символа', () => {
+        expect(is_char('a')).toBe(true);
+    });
+
+    test('Должна возвращать false для строки из нескольких символов', () => {
+        expect(is_char('abc')).toBe(false);
+    });
+
+    test('Должна возвращать false для пустой строки', () => {
+        expect(is_char('')).toBe(false);
+    });
+
+    test('Должна возвращать false для значения, не являющегося строкой', () => {
+        expect(is_char(1)).toBe(false);
+        expect(is_char(null)).toBe(false);
+        expect(is_char(undefined)).toBe(false);
+        expect(is_char({})).toBe(false);
+        expect(is_char([])).toBe(false);
+    });
+
+    test('Должна возвращать true для пробельного символа', () => {
+        expect(is_char(' ')).toBe(true);
+    });
+
+    test('Должна возвращать false для строки с пробелами', () => {
+        expect(is_char(' a ')).toBe(false);
+    });
+
+    test('Должна возвращать false для строки с числовыми значениями', () => {
+        expect(is_char('123')).toBe(false);
+    });
+
+    test('Должна возвращать true для одиночного числового символа', () => {
+        expect(is_char('1')).toBe(true);
+    });
+});

package/tests/helpers/string/is_digit_char.test.mjs

@@ -0,0 +1,32 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_digit_char } from '../../../index.mjs';
+
+describe('Функция is_digit_char', () => {
+    test('Должна возвращать true для цифрового символа', () => {
+        expect(is_digit_char('0')).toBe(true);
+        expect(is_digit_char('5')).toBe(true);
+        expect(is_digit_char('9')).toBe(true);
+    });
+
+    test('Должна возвращать false для непробельного символа', () => {
+        expect(is_digit_char('a')).toBe(false);
+        expect(is_digit_char(' ')).toBe(false);
+        expect(is_digit_char('!')).toBe(false);
+    });
+
+    test('Должна возвращать false для строки из нескольких символов', () => {
+        expect(is_digit_char('123')).toBe(false);
+    });
+
+    test('Должна возвращать false для пустой строки', () => {
+        expect(is_digit_char('')).toBe(false);
+    });
+
+    test('Должна возвращать false для значения, не являющегося строкой', () => {
+        expect(is_digit_char(1)).toBe(false);
+        expect(is_digit_char(null)).toBe(false);
+        expect(is_digit_char(undefined)).toBe(false);
+        expect(is_digit_char({})).toBe(false);
+        expect(is_digit_char([])).toBe(false);
+    });
+});

package/tests/helpers/string/is_whitespace_char.test.mjs

@@ -0,0 +1,32 @@
+import { expect, test, describe } from '@jest/globals';
+import { is_whitespace_char } from '../../../index.mjs';
+
+describe('Функция is_whitespace_char', () => {
+    test('Должна возвращать true для пробельного символа', () => {
+        expect(is_whitespace_char(' ')).toBe(true);
+        expect(is_whitespace_char('\t')).toBe(true);
+        expect(is_whitespace_char('\n')).toBe(true);
+    });
+
+    test('Должна возвращать false для непробельного символа', () => {
+        expect(is_whitespace_char('a')).toBe(false);
+        expect(is_whitespace_char('1')).toBe(false);
+        expect(is_whitespace_char('!')).toBe(false);
+    });
+
+    test('Должна возвращать false для строки из нескольких символов', () => {
+        expect(is_whitespace_char('abc')).toBe(false);
+    });
+
+    test('Должна возвращать false для пустой строки', () => {
+        expect(is_whitespace_char('')).toBe(false);
+    });
+
+    test('Должна возвращать false для значения, не являющегося строкой', () => {
+        expect(is_whitespace_char(1)).toBe(false);
+        expect(is_whitespace_char(null)).toBe(false);
+        expect(is_whitespace_char(undefined)).toBe(false);
+        expect(is_whitespace_char({})).toBe(false);
+        expect(is_whitespace_char([])).toBe(false);
+    });
+});

package/tests/helpers/string/natcompare.test.mjs

@@ -0,0 +1,100 @@
+import { expect, test, describe } from '@jest/globals';
+import { natcompare } from '../../../index.mjs';
+
+describe('Функция natcompare', () => {
+    test('Должна корректно сравнивать строки с числовыми значениями', () => {
+        expect(natcompare('10', '2')).toBeGreaterThan(0);
+        expect(natcompare('2', '10')).toBeLessThan(0);
+        expect(natcompare('10', '10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с ведущими нулями', () => {
+        expect(natcompare('0010', '10')).toBe(0);
+        expect(natcompare('010', '10')).toBe(0);
+        expect(natcompare('10', '0010')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с пробелами', () => {
+        expect(natcompare(' 10', '10')).toBe(0);
+        expect(natcompare('10', ' 10')).toBe(0);
+        expect(natcompare(' 10', ' 10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с буквами и числами', () => {
+        expect(natcompare('a10', 'a2')).toBeGreaterThan(0);
+        expect(natcompare('a2', 'a10')).toBeLessThan(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с разными символами', () => {
+        expect(natcompare('10-', '10+')).toBeGreaterThan(0);
+        expect(natcompare('10+', '10-')).toBeLessThan(0);
+        expect(natcompare('10-', '10-')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными буквами', () => {
+        expect(natcompare('10a', '10b')).toBeLessThan(0);
+        expect(natcompare('10b', '10a')).toBeGreaterThan(0);
+        expect(natcompare('10a', '10a')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными регистрами', () => {
+        expect(natcompare('10A', '10a')).toBeLessThan(0);
+        expect(natcompare('10a', '10A')).toBeGreaterThan(0);
+        expect(natcompare('10A', '10A')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными пробелами', () => {
+        expect(natcompare('10 ', '10')).toBe(0);
+        expect(natcompare('10', '10 ')).toBe(0);
+        expect(natcompare('10 ', '10 ')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми буквами и разными числовыми значениями', () => {
+        expect(natcompare('a10', 'a2')).toBeGreaterThan(0);
+        expect(natcompare('a2', 'a10')).toBeLessThan(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми буквами и одинаковыми числовыми значениями', () => {
+        expect(natcompare('a10', 'a10')).toBe(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+        expect(natcompare('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с разными длинами', () => {
+        expect(natcompare('a', 'aa')).toBeLessThan(0);
+        expect(natcompare('aa', 'a')).toBeGreaterThan(0);
+        expect(natcompare('a', 'a')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми длинами и разными символами', () => {
+        expect(natcompare('a1', 'a2')).toBeLessThan(0);
+        expect(natcompare('a2', 'a1')).toBeGreaterThan(0);
+        expect(natcompare('a1', 'a1')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми длинами и одинаковыми символами', () => {
+        expect(natcompare('a1', 'a1')).toBe(0);
+        expect(natcompare('a1', 'a1')).toBe(0);
+        expect(natcompare('a1', 'a1')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях', () => {
+        expect(natcompare('a1b2', 'a1b10')).toBeLessThan(0);
+        expect(natcompare('a1b10', 'a1b2')).toBeGreaterThan(0);
+        expect(natcompare('a1b2', 'a1b2')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях и разными регистрами', () => {
+        expect(natcompare('a1B2', 'a1b10')).toBeLessThan(0);
+        expect(natcompare('a1b10', 'a1B2')).toBeGreaterThan(0);
+        expect(natcompare('a1B2', 'a1B2')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях и разными символами', () => {
+        expect(natcompare('a1-b2', 'a1+b10')).toBeLessThan(0);
+        expect(natcompare('a1+b10', 'a1-b2')).toBeGreaterThan(0);
+        expect(natcompare('a1-b2', 'a1-b2')).toBe(0);
+    });
+});

package/tests/helpers/string/natcompare_numeric.test.mjs

@@ -0,0 +1,110 @@
+import { expect, test, describe } from '@jest/globals';
+import { natcompare_numeric } from '../../../index.mjs';
+
+describe('Функция natcompare_numeric', () => {
+    test('Должна корректно сравнивать строки с числовыми значениями', () => {
+        expect(natcompare_numeric('10', '2')).toBeGreaterThan(0);
+        expect(natcompare_numeric('2', '10')).toBeLessThan(0);
+        expect(natcompare_numeric('10', '10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с ведущими нулями', () => {
+        expect(natcompare_numeric('0010', '10')).toBe(0);
+        expect(natcompare_numeric('010', '10')).toBe(0);
+        expect(natcompare_numeric('10', '0010')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с пробелами', () => {
+        expect(natcompare_numeric(' 10', '10')).toBe(0);
+        expect(natcompare_numeric('10', ' 10')).toBe(0);
+        expect(natcompare_numeric(' 10', ' 10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с буквами и числами', () => {
+        expect(natcompare_numeric('a10', 'a2')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a2', 'a10')).toBeLessThan(0);
+        expect(natcompare_numeric('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с разными символами', () => {
+        expect(natcompare_numeric('10-', '10+')).toBe(0);
+        expect(natcompare_numeric('10+', '10-')).toBe(0);
+        expect(natcompare_numeric('10-', '10-')).toBe(0);
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "a" не является строкой', () => {
+        expect(() => natcompare_numeric(10, '2')).toThrow(TypeError);
+        expect(() => natcompare_numeric(10, '2')).toThrow('Параметр "a" должен быть строкой.');
+    });
+
+    test('Должна выбрасывать ошибку, если параметр "b" не является строкой', () => {
+        expect(() => natcompare_numeric('10', 2)).toThrow(TypeError);
+        expect(() => natcompare_numeric('10', 2)).toThrow('Параметр "b" должен быть строкой.');
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными буквами', () => {
+        expect(natcompare_numeric('10a', '10b')).toBe(0);
+        expect(natcompare_numeric('10b', '10a')).toBe(0);
+        expect(natcompare_numeric('10a', '10a')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными регистрами', () => {
+        expect(natcompare_numeric('10A', '10a')).toBe(0);
+        expect(natcompare_numeric('10a', '10A')).toBe(0);
+        expect(natcompare_numeric('10A', '10A')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми числовыми значениями и разными пробелами', () => {
+        expect(natcompare_numeric('10 ', '10')).toBe(0);
+        expect(natcompare_numeric('10', '10 ')).toBe(0);
+        expect(natcompare_numeric('10 ', '10 ')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми буквами и разными числовыми значениями', () => {
+        expect(natcompare_numeric('a10', 'a2')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a2', 'a10')).toBeLessThan(0);
+        expect(natcompare_numeric('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми буквами и одинаковыми числовыми значениями', () => {
+        expect(natcompare_numeric('a10', 'a10')).toBe(0);
+        expect(natcompare_numeric('a10', 'a10')).toBe(0);
+        expect(natcompare_numeric('a10', 'a10')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с разными длинами', () => {
+        expect(natcompare_numeric('a', 'aa')).toBeLessThan(0);
+        expect(natcompare_numeric('aa', 'a')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a', 'a')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми длинами и разными символами', () => {
+        expect(natcompare_numeric('a1', 'a2')).toBeLessThan(0);
+        expect(natcompare_numeric('a2', 'a1')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a1', 'a1')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с одинаковыми длинами и одинаковыми символами', () => {
+        expect(natcompare_numeric('a1', 'a1')).toBe(0);
+        expect(natcompare_numeric('a1', 'a1')).toBe(0);
+        expect(natcompare_numeric('a1', 'a1')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях', () => {
+        expect(natcompare_numeric('a1b2', 'a1b10')).toBeLessThan(0);
+        expect(natcompare_numeric('a1b10', 'a1b2')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a1b2', 'a1b2')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях и разными регистрами', () => {
+        expect(natcompare_numeric('a1B2', 'a1b10')).toBeLessThan(0);
+        expect(natcompare_numeric('a1b10', 'a1B2')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a1B2', 'a1B2')).toBe(0);
+    });
+
+    test('Должна корректно сравнивать строки с числами и буквами в разных позициях и разными символами', () => {
+        expect(natcompare_numeric('a1-b2', 'a1+b10')).toBeLessThan(0);
+        expect(natcompare_numeric('a1+b10', 'a1-b2')).toBeGreaterThan(0);
+        expect(natcompare_numeric('a1-b2', 'a1-b2')).toBe(0);
+    });
+});