@rogolev/value 0.0.3 → 0.0.4

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

@@ -0,0 +1,64 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_diff_key } from '../../../index.mjs';
+
+describe('Функция array_diff_key', () => {
+    test('Должна возвращать элементы из первого массива, которые отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const result = array_diff_key(original_array, array1);
+        expect(result).toEqual({ c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { a: 1, b: 2 };
+        const result = array_diff_key(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_diff_key(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_diff_key('not an array')).toThrow(TypeError);
+        expect(() => array_diff_key('not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_diff_key([], 'not an array')).toThrow(TypeError);
+        expect(() => array_diff_key([], 'not an array')).toThrow(
+            'Параметр "arrays" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_diff_key(original_array, array1);
+        expect(result).toEqual({ c: true });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_diff_key(original_array, array1, array2);
+        expect(result).toEqual({ d: 4 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_diff_key(original_array, array1);
+        expect(result).toEqual({ b: { id: 2, data: [3, 4] } });
+    });
+});

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

@@ -0,0 +1,73 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_diff_uassoc } from '../../../index.mjs';
+
+describe('Функция array_diff_uassoc', () => {
+    const key_compare_func = (a, b) => a === b;
+
+    test('Должна возвращать элементы из первого массива, которые отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const result = array_diff_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({ c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { a: 1, b: 2 };
+        const result = array_diff_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_diff_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для key_compare_func не является функцией', () => {
+        expect(() => array_diff_uassoc('not a function', {})).toThrow(TypeError);
+        expect(() => array_diff_uassoc('not a function', {})).toThrow(
+            'Параметр "key_compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_diff_uassoc(key_compare_func, 'not an array')).toThrow(TypeError);
+        expect(() => array_diff_uassoc(key_compare_func, 'not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_diff_uassoc(key_compare_func, {}, 'not an array')).toThrow(TypeError);
+        expect(() => array_diff_uassoc(key_compare_func, {}, 'not an array')).toThrow(
+            'Параметр "arrays" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_diff_uassoc(key_compare_func, original_array, array1);
+        expect(result).toEqual({ b: '2', c: true });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_diff_uassoc(key_compare_func, original_array, array1, array2);
+        expect(result).toEqual({ d: 4 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_diff_uassoc((a, b) => a === b, original_array, array1);
+        expect(result).toEqual({ b: { id: 2, data: [3, 4] } });
+    });
+});

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

@@ -0,0 +1,77 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_diff_ukey } from '../../../index.mjs';
+
+describe('Функция array_diff_ukey', () => {
+    const key_compare_func = (a, b) => a === b;
+
+    test('Должна возвращать элементы из первого массива, которые отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const result = array_diff_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({ c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { a: 1, b: 2 };
+        const result = array_diff_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_diff_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для key_compare_func не является функцией', () => {
+        expect(() => array_diff_ukey('not a function', {})).toThrow(TypeError);
+        expect(() => array_diff_ukey('not a function', {})).toThrow(
+            'Параметр "key_compare_func" должен быть функцией.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_diff_ukey(key_compare_func, 'not an array')).toThrow(TypeError);
+        expect(() => array_diff_ukey(key_compare_func, 'not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_diff_ukey(key_compare_func, {}, 'not an array')).toThrow(TypeError);
+        expect(() => array_diff_ukey(key_compare_func, {}, 'not an array')).toThrow(
+            'Параметр "arrays" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_diff_ukey(key_compare_func, original_array, array1);
+        expect(result).toEqual({ c: true });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_diff_ukey(key_compare_func, original_array, array1, array2);
+        expect(result).toEqual({ d: 4 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_diff_ukey(
+            (a, b) => JSON.stringify(a) === JSON.stringify(b),
+            original_array,
+            array1,
+        );
+        expect(result).toEqual({ b: { id: 2, data: [3, 4] } });
+    });
+});

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

@@ -0,0 +1,47 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_fill } from '../../../index.mjs';
+
+describe('Функция array_fill', () => {
+    test('Должна заполнять пустой массив значениями', () => {
+        const result = array_fill([], 0, 3, 'a');
+        expect(result).toEqual(['a', 'a', 'a']);
+    });
+
+    test('Должна заполнять массив значениями с указанного индекса', () => {
+        const result = array_fill([], 2, 3, 'b');
+        expect(result).toEqual([undefined, undefined, 'b', 'b', 'b']);
+    });
+
+    test('Должна заполнять существующий массив значениями', () => {
+        const existingArray = [1, 2, 3];
+        const result = array_fill(existingArray, 1, 2, 'c');
+        expect(result).toEqual([1, 'c', 'c']);
+    });
+
+    test('Должна выбрасывать ошибку при отрицательном значении для count', () => {
+        expect(() => array_fill([], 0, -1, 'd')).toThrow(TypeError);
+        expect(() => array_fill([], 0, -1, 'd')).toThrow(
+            'Параметр "count" должен быть равен или больше нуля.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку при значении start_index, не являющемся целым числом', () => {
+        expect(() => array_fill([], 0.5, 3, 'e')).toThrow(TypeError);
+        expect(() => array_fill([], 0.5, 3, 'e')).toThrow(
+            'Параметр "start_index" должен быть целым числом.',
+        );
+    });
+
+    test('Должна заполнять ассоциативный массив значениями', () => {
+        const assocArray = { a: 1, b: 2 };
+        const result = array_fill(assocArray, 2, 3, 'f');
+        expect(result).toEqual({ a: 1, b: 2, 2: 'f', 3: 'f', 4: 'f' });
+    });
+
+    test('Должна выбрасывать ошибку, если arr не является массивом', () => {
+        expect(() => array_fill('not an array', 0, 3, 'g')).toThrow(TypeError);
+        expect(() => array_fill('not an array', 0, 3, 'g')).toThrow(
+            'Параметр "arr" должен быть массивом.',
+        );
+    });
+});

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_flip } from '../../../index.mjs';
+
+describe('Функция array_flip', () => {
+    test('Должна менять местами ключи и значения в обычном массиве', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = array_flip(array);
+        expect(result).toEqual({ 1: 'a', 2: 'b', 3: 'c' });
+    });
+
+    test('Должна обрабатывать пустой массив', () => {
+        const array = {};
+        const result = array_flip(array);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если value не является массивом', () => {
+        expect(() => array_flip('not an array')).toThrow(TypeError);
+        expect(() => array_flip('not an array')).toThrow('Параметр "value" должен быть массивом.');
+    });
+
+    test('Должна корректно обрабатывать массив с повторяющимися значениями', () => {
+        const array = { a: 1, b: 1, c: 2 };
+        const result = array_flip(array);
+        expect(result).toEqual({ 1: 'b', 2: 'c' });
+    });
+
+    test('Должна корректно обрабатывать массив с различными типами данных', () => {
+        const array = { a: 1, b: '2', c: true };
+        const result = array_flip(array);
+        expect(result).toEqual({ 1: 'a', 2: 'b', true: 'c' });
+    });
+});

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

@@ -0,0 +1,41 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_index_max } from '../../../index.mjs';
+
+describe('Функция array_index_max', () => {
+    test('Должна возвращать максимальный индекс обычного массива', () => {
+        const array = [1, 2, 3];
+        const result = array_index_max(array);
+        expect(result).toBe(2);
+    });
+
+    test('Должна возвращать null для ассоциативного массива без числовых ключей', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = array_index_max(array);
+        expect(result).toBeNull();
+    });
+
+    test('Должна возвращать максимальный числовой ключ для ассоциативного массива с числовыми ключами', () => {
+        const array = { a: 1, 2: 'b', 3: 'c' };
+        const result = array_index_max(array);
+        expect(result).toBe(3);
+    });
+
+    test('Должна возвращать null для пустого массива', () => {
+        const array = [];
+        const result = array_index_max(array);
+        expect(result).toBeNull();
+    });
+
+    test('Должна выбрасывать ошибку, если value не является массивом', () => {
+        expect(() => array_index_max('not an array')).toThrow(TypeError);
+        expect(() => array_index_max('not an array')).toThrow(
+            'Параметр "value" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массив с различными типами данных', () => {
+        const array = { a: 1, b: '2', 3: true };
+        const result = array_index_max(array);
+        expect(result).toBe(3);
+    });
+});

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

@@ -0,0 +1,41 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_index_min } from '../../../index.mjs';
+
+describe('Функция array_index_min', () => {
+    test('Должна возвращать минимальный индекс обычного массива', () => {
+        const array = [1, 2, 3];
+        const result = array_index_min(array);
+        expect(result).toBe(0);
+    });
+
+    test('Должна возвращать null для ассоциативного массива без числовых ключей', () => {
+        const array = { a: 1, b: 2, c: 3 };
+        const result = array_index_min(array);
+        expect(result).toBeNull();
+    });
+
+    test('Должна возвращать минимальный числовой ключ для ассоциативного массива с числовыми ключами', () => {
+        const array = { 1: 'a', 2: 'b', 3: 'c' };
+        const result = array_index_min(array);
+        expect(result).toBe(1);
+    });
+
+    test('Должна возвращать null для пустого массива', () => {
+        const array = [];
+        const result = array_index_min(array);
+        expect(result).toBeNull();
+    });
+
+    test('Должна выбрасывать ошибку, если value не является массивом', () => {
+        expect(() => array_index_min('not an array')).toThrow(TypeError);
+        expect(() => array_index_min('not an array')).toThrow(
+            'Параметр "value" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массив с различными типами данных', () => {
+        const array = { a: 1, b: '2', 3: true };
+        const result = array_index_min(array);
+        expect(result).toBe(3);
+    });
+});

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

@@ -0,0 +1,65 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_intersect } from '../../../index.mjs';
+
+describe('Функция array_intersect', () => {
+    test('Должна возвращать элементы из первого массива, которые присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { b: 2, c: 3 };
+        const result = array_intersect(original_array, array1, array2);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { c: 3, d: 4 };
+        const result = array_intersect(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_intersect(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_intersect('not an array')).toThrow(TypeError);
+        expect(() => array_intersect('not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_intersect({}, 'not an array')).toThrow(TypeError);
+        expect(() => array_intersect({}, 'not an array')).toThrow(
+            'Параметр "arrays" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_intersect(original_array, array1);
+        expect(result).toEqual({ a: 1 });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_intersect(original_array, array1, array2);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_intersect(original_array, array1);
+        expect(result).toEqual({ a: { id: 1, data: [1, 2] } });
+    });
+});

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

@@ -0,0 +1,65 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_intersect_assoc } from '../../../index.mjs';
+
+describe('Функция array_intersect_assoc', () => {
+    test('Должна возвращать элементы из первого массива, которые присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { b: 2, c: 3 };
+        const result = array_intersect_assoc(original_array, array1, array2);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { c: 3, d: 4 };
+        const result = array_intersect_assoc(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_intersect_assoc(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_intersect_assoc('not an array')).toThrow(TypeError);
+        expect(() => array_intersect_assoc('not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_intersect_assoc({}, 'not an array')).toThrow(TypeError);
+        expect(() => array_intersect_assoc({}, 'not an array')).toThrow(
+            'Параметр "arrays" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_intersect_assoc(original_array, array1);
+        expect(result).toEqual({ a: 1 });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_intersect_assoc(original_array, array1, array2);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_intersect_assoc(original_array, array1);
+        expect(result).toEqual({ a: { id: 1, data: [1, 2] } });
+    });
+});

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

@@ -0,0 +1,65 @@
+import { expect, test, describe } from '@jest/globals';
+import { array_intersect_key } from '../../../index.mjs';
+
+describe('Функция array_intersect_key', () => {
+    test('Должна возвращать элементы из первого массива, которые присутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2, c: 3 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { b: 2, c: 3 };
+        const result = array_intersect_key(original_array, array1, array2);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна возвращать пустой объект, если все элементы первого массива отсутствуют в других массивах', () => {
+        const original_array = { a: 1, b: 2 };
+        const array1 = { c: 3, d: 4 };
+        const result = array_intersect_key(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна корректно обрабатывать пустые массивы', () => {
+        const original_array = {};
+        const array1 = {};
+        const result = array_intersect_key(original_array, array1);
+        expect(result).toEqual({});
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для original_array не является массивом', () => {
+        expect(() => array_intersect_key('not an array')).toThrow(TypeError);
+        expect(() => array_intersect_key('not an array')).toThrow(
+            'Параметр "original_array" должен быть массивом.',
+        );
+    });
+
+    test('Должна выбрасывать ошибку, если переданное значение для arrays не является массивом', () => {
+        expect(() => array_intersect_key({}, 'not an array')).toThrow(TypeError);
+        expect(() => array_intersect_key({}, 'not an array')).toThrow(
+            'Параметр "arrays" должен быть массивом.',
+        );
+    });
+
+    test('Должна корректно обрабатывать массивы с различными типами данных', () => {
+        const original_array = { a: 1, b: '2', c: true };
+        const array1 = { a: 1, b: 2, d: false };
+        const result = array_intersect_key(original_array, array1);
+        expect(result).toEqual({ a: 1, b: '2' });
+    });
+
+    test('Должна корректно обрабатывать несколько массивов для сравнения', () => {
+        const original_array = { a: 1, b: 2, c: 3, d: 4 };
+        const array1 = { a: 1, b: 2 };
+        const array2 = { c: 3 };
+        const result = array_intersect_key(original_array, array1, array2);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    test('Должна корректно обрабатывать массивы с вложенными структурами', () => {
+        const original_array = {
+            a: { id: 1, data: [1, 2] },
+            b: { id: 2, data: [3, 4] },
+        };
+        const array1 = { a: { id: 1, data: [1, 2] } };
+        const result = array_intersect_key(original_array, array1);
+        expect(result).toEqual({ a: { id: 1, data: [1, 2] } });
+    });
+});