mielk-fn 1.2.4 → 1.2.6

package/dist/arrays/arrays.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/arrays/arrays.spec.js

@@ -0,0 +1,89 @@
+import { toIndexedArray, toMap } from "./arrays.js";
+describe('toMap', () => {
+    const objects = [
+        { name: 'Adam', id: 1 },
+        { name: 'Bartek', id: 4 },
+        { name: 'Czesiek', id: 5 },
+    ];
+    const primitives = ['Adam', 'Bartek', 'Czesiek'];
+    it('should create a map from an array of objects', () => {
+        const map = toMap(objects, (obj) => obj.id);
+        expect(map.size).toBe(3);
+        expect(map.get(1)).toEqual(objects[0]);
+        expect(map.get(4)).toEqual(objects[1]);
+        expect(map.get(5)).toEqual(objects[2]);
+    });
+    it('should create a map from an array of primitives', () => {
+        const map = toMap(primitives, (str) => str.charAt(0));
+        expect(map.size).toBe(3);
+        expect(map.get('A')).toEqual(primitives[0]);
+        expect(map.get('B')).toEqual(primitives[1]);
+        expect(map.get('C')).toEqual(primitives[2]);
+    });
+    it('should allow custom value callback', () => {
+        const map = toMap(objects, (obj) => obj.id, (obj) => obj.name);
+        expect(map.size).toBe(3);
+        expect(map.get(1)).toBe('Adam');
+        expect(map.get(4)).toBe('Bartek');
+        expect(map.get(5)).toBe('Czesiek');
+    });
+    it('should ignore duplicate keys by default', () => {
+        const objectsWithDuplicate = [
+            { name: 'Adam', id: 1 },
+            { name: 'Bartek', id: 4 },
+            { name: 'Czesiek', id: 4 },
+        ];
+        const map = toMap(objectsWithDuplicate, (obj) => obj.id);
+        expect(map.size).toBe(2);
+        expect(map.get(1)).toEqual(objectsWithDuplicate[0]);
+        expect(map.get(4)).toEqual(objectsWithDuplicate[1]);
+    });
+});
+describe('toIndexedArray', () => {
+    it('should return an indexed array with basic objects', () => {
+        const items = [
+            { name: 'Adam', id: 1 },
+            { name: 'Bartek', id: 4 },
+            { name: 'Czesiek', id: 5 },
+        ];
+        const callback = (item) => item.id;
+        const result = toIndexedArray(items, callback);
+        expect(result[1]).toEqual({ name: 'Adam', id: 1 });
+        expect(result[4]).toEqual({ name: 'Bartek', id: 4 });
+        expect(result[5]).toEqual({ name: 'Czesiek', id: 5 });
+    });
+    it('should handle custom class instances', () => {
+        class Person {
+            constructor(fullName, id) {
+                this.fullName = fullName;
+                this.id = id;
+            }
+        }
+        const items = [new Person('Adam', 1), new Person('Bartek', 4), new Person('Czesiek', 5)];
+        const callback = (item) => {
+            if (typeof item === 'object' && item !== null && 'id' in item) {
+                return item.id;
+            }
+            return -1;
+        };
+        const result = toIndexedArray(items, callback);
+        expect(result[1]).toEqual(new Person('Adam', 1));
+        expect(result[4]).toEqual(new Person('Bartek', 4));
+        expect(result[5]).toEqual(new Person('Czesiek', 5));
+    });
+    it('should throw an error when the callback returns a non-number value', () => {
+        const items = [
+            { name: 'Adam', id: '1' },
+            { name: 'Bartek', id: '4' },
+            { name: 'Czesiek', id: '5' },
+        ];
+        const callback = (item) => item.id;
+        expect(() => toIndexedArray(items, callback)).toThrow(new TypeError('Callback should return a number.'));
+    });
+    it('should handle an empty array', () => {
+        const items = [];
+        const callback = (item) => item.id;
+        const result = toIndexedArray(items, callback);
+        expect(result).toEqual([]);
+    });
+});

package/dist/dates/dates.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dates/dates.spec.js

@@ -0,0 +1,47 @@
+import { formatDateDefault } from "./dates";
+describe('formatDateDefault', () => {
+    it('should return empty string for undefined', () => {
+        expect(formatDateDefault(undefined)).toBe('');
+    });
+    it('should return string in format YYYY-MM-DD HH:mm:ss', () => {
+        const date = new Date('2024-01-02T03:04:05Z');
+        const result = formatDateDefault(date);
+        expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+    });
+    it('should always have 2-digit month, day, hour, minute, second', () => {
+        const date = new Date('2024-04-05T06:07:08Z');
+        const result = formatDateDefault(date);
+        const [datePart, timePart] = result.split(' ');
+        const [year, month, day] = datePart.split('-');
+        const [hour, minute, second] = timePart.split(':');
+        expect(year.length).toBe(4);
+        expect(month.length).toBe(2);
+        expect(day.length).toBe(2);
+        expect(hour.length).toBe(2);
+        expect(minute.length).toBe(2);
+        expect(second.length).toBe(2);
+    });
+    it('should accept custom timeZone parameter', () => {
+        const date = new Date('2024-01-02T03:04:05Z');
+        const result = formatDateDefault(date, 'UTC');
+        expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+    });
+    it('should still return valid structure for different time zones', () => {
+        const date = new Date('2024-06-15T10:20:30Z');
+        const resultWarsaw = formatDateDefault(date, 'Europe/Warsaw');
+        const resultUTC = formatDateDefault(date, 'UTC');
+        expect(resultWarsaw).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+        expect(resultUTC).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+        expect(resultWarsaw).not.toBe(resultUTC);
+    });
+    it('should be deterministic', () => {
+        const date = new Date('2024-06-15T10:20:30Z');
+        expect(formatDateDefault(date)).toBe(formatDateDefault(date));
+    });
+    it('should not mutate input date', () => {
+        const date = new Date('2024-01-01T00:00:00Z');
+        const time = date.getTime();
+        formatDateDefault(date);
+        expect(date.getTime()).toBe(time);
+    });
+});

package/dist/io/io.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/io/io.spec.js

@@ -0,0 +1,66 @@
+import { parseJsonFile } from './io.js';
+describe('parseJson', () => {
+    it('should return default object when valid', () => {
+        const input = {
+            a: 12,
+            default: { x: 1, y: 2 },
+        };
+        expect(parseJsonFile(input)).toEqual({ x: 1, y: 2 });
+    });
+    it('should return empty object when default is missing', () => {
+        const input = { a: 12, b: 23 };
+        expect(parseJsonFile(input)).toEqual({});
+    });
+    it('should return empty object when default is null', () => {
+        const input = { default: null };
+        expect(parseJsonFile(input)).toEqual({});
+    });
+    it('should return empty object when default is not an object', () => {
+        expect(parseJsonFile({ default: 123 })).toEqual({});
+        expect(parseJsonFile({ default: 'text' })).toEqual({});
+        expect(parseJsonFile({ default: true })).toEqual({});
+    });
+    it('should return empty object when default is an array', () => {
+        expect(parseJsonFile({ default: [] })).toEqual({});
+    });
+    it('should return empty object when input is null', () => {
+        expect(parseJsonFile(null)).toEqual({});
+    });
+    it('should return empty object when input is undefined', () => {
+        expect(parseJsonFile(undefined)).toEqual({});
+    });
+    it('should return empty object when input is primitive', () => {
+        expect(parseJsonFile(123)).toEqual({});
+        expect(parseJsonFile('text')).toEqual({});
+        expect(parseJsonFile(true)).toEqual({});
+    });
+    it('should return empty object when input is array', () => {
+        expect(parseJsonFile([])).toEqual({});
+    });
+    it('should return empty object when default is a special object (Date, Map, etc.)', () => {
+        expect(parseJsonFile({ default: new Date() })).toEqual({});
+        expect(parseJsonFile({ default: new Map() })).toEqual({});
+    });
+    it('should handle nested default object', () => {
+        const input = {
+            default: {
+                nested: {
+                    value: 42,
+                },
+            },
+        };
+        expect(parseJsonFile(input)).toEqual({
+            nested: {
+                value: 42,
+            },
+        });
+    });
+    it('should not mutate input object', () => {
+        const input = {
+            default: { a: 1 },
+        };
+        const result = parseJsonFile(input);
+        expect(result).toEqual({ a: 1 });
+        expect(input.default).toEqual({ a: 1 });
+    });
+});

package/dist/math/math.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math/math.spec.js

@@ -0,0 +1,73 @@
+import { formatPercent, formatWithSign } from "./math";
+describe('formatWithSign', () => {
+    it('formats positive numbers with + sign', () => {
+        expect(formatWithSign(1.234)).toBe('+1');
+    });
+    it('formats negative numbers with unicode minus', () => {
+        expect(formatWithSign(-1.234)).toBe('−1');
+    });
+    it('returns plain zero without sign', () => {
+        expect(formatWithSign(0)).toBe('0');
+    });
+    it('respects decimals', () => {
+        expect(formatWithSign(1.234, 2)).toBe('+1.23');
+        expect(formatWithSign(-1.234, 2)).toBe('−1.23');
+    });
+    it('rounds values correctly', () => {
+        expect(formatWithSign(1.235, 2)).toBe('+1.24');
+        expect(formatWithSign(-1.235, 2)).toBe('−1.24');
+    });
+    it('handles NaN', () => {
+        expect(formatWithSign(NaN)).toBe('NaN');
+    });
+    it('handles Infinity', () => {
+        expect(formatWithSign(Infinity)).toBe('+Infinity');
+        expect(formatWithSign(-Infinity)).toBe('−Infinity');
+    });
+    it('handles very large numbers', () => {
+        expect(formatWithSign(1e20)).toBe('+100000000000000000000');
+    });
+    it('handles very small numbers', () => {
+        expect(formatWithSign(1e-10, 0)).toBe('+0');
+    });
+});
+describe('formatPercent', () => {
+    it('formats positive percentages without plus by default', () => {
+        expect(formatPercent(0.1234)).toBe('12%');
+    });
+    it('formats positive percentages with plus when flag is true', () => {
+        expect(formatPercent(0.1234, 2, true)).toBe('+12.34%');
+    });
+    it('formats negative percentages', () => {
+        expect(formatPercent(-0.1234)).toBe('−12%');
+    });
+    it('formats negative percentages with decimals', () => {
+        expect(formatPercent(-0.1234, 2)).toBe('−12.34%');
+    });
+    it('handles zero', () => {
+        expect(formatPercent(0)).toBe('0%');
+    });
+    it('handles zero with plus flag (still no sign)', () => {
+        expect(formatPercent(0, 0, true)).toBe('0%');
+    });
+    it('handles zero with fraction and plus flag (still no sign)', () => {
+        expect(formatPercent(0, 2, true)).toBe('0.00%');
+    });
+    it('respects decimals', () => {
+        expect(formatPercent(0.1234, 2)).toBe('12.34%');
+    });
+    it('multiplies by 100 correctly', () => {
+        expect(formatPercent(1)).toBe('100%');
+        expect(formatPercent(0.01)).toBe('1%');
+    });
+    it('rounds correctly', () => {
+        expect(formatPercent(0.01479, 2)).toBe('1.48%');
+    });
+    it('handles NaN', () => {
+        expect(formatPercent(NaN)).toBe('NaN%');
+    });
+    it('handles Infinity', () => {
+        expect(formatPercent(Infinity)).toBe('Infinity%');
+        expect(formatPercent(-Infinity)).toBe('−Infinity%');
+    });
+});

package/dist/objects/objects.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/objects/objects.spec.js

@@ -0,0 +1,199 @@
+import { invert, isNonEmptyObject, merge, modifyKeys } from "./objects.js";
+describe('invert', () => {
+    it('Basic case', () => {
+        const input = { key1: 'value1', key2: 'value2' };
+        const result = invert(input);
+        expect(result).toEqual({ value1: 'key1', value2: 'key2' });
+    });
+    it('Number keys and values', () => {
+        const input = { 1: 2, 3: 4 };
+        const result = invert(input);
+        expect(result).toEqual({ 2: '1', 4: '3' });
+    });
+    it('Mixed keys and values', () => {
+        const input = { key1: 1, 2: 'value2' };
+        const result = invert(input);
+        expect(result).toEqual({ 1: 'key1', value2: '2' });
+    });
+    it('Empty object', () => {
+        const input = {};
+        const result = invert(input);
+        expect(result).toEqual({});
+    });
+    it('Non-object input', () => {
+        const input = 'string';
+        expect(() => invert(input)).toThrow('Invalid input: the input must be an object.');
+    });
+    it('Invalid value type', () => {
+        const input = { key1: true };
+        expect(() => invert(input)).toThrow('Invalid value type: the value must be a string or a number.');
+    });
+    it('should invert object with string keys and number values', () => {
+        const obj = { a: 1, b: 2, c: 3 };
+        const result = invert(obj);
+        expect(result).toEqual({ '1': 'a', '2': 'b', '3': 'c' });
+    });
+    it('should invert object with number keys and string values', () => {
+        const obj = { '1': 'a', '2': 'b', '3': 'c' };
+        const result = invert(obj);
+        expect(result).toEqual({ a: '1', b: '2', c: '3' });
+    });
+    it('should invert object with string keys and string values', () => {
+        const obj = { a: '1', b: '2', c: '3' };
+        const result = invert(obj);
+        expect(result).toEqual({ '1': 'a', '2': 'b', '3': 'c' });
+    });
+    it('should invert object with number keys and number values', () => {
+        const obj = { '1': 2, '3': 4, '5': 6 };
+        const result = invert(obj);
+        expect(result).toEqual({ '2': '1', '4': '3', '6': '5' });
+    });
+    it('should invert object with unusual but valid keys or values', () => {
+        const obj = { '': 1, a: 0, b: -1 };
+        const result = invert(obj);
+        expect(result).toEqual({ '1': '', '0': 'a', '-1': 'b' });
+    });
+});
+describe('isNonEmptyObject', () => {
+    it('should return false for a number', () => {
+        expect(isNonEmptyObject(1)).toBeFalsy();
+    });
+    it('should return false for a text', () => {
+        expect(isNonEmptyObject('a')).toBeFalsy();
+    });
+    it('should return false for non-empty array', () => {
+        expect(isNonEmptyObject([1, 2, 3])).toBeFalsy();
+    });
+    it('should return false for empty array', () => {
+        expect(isNonEmptyObject([])).toBeFalsy();
+    });
+    it('should return false for multidimensional array', () => {
+        expect(isNonEmptyObject([[], []])).toBeFalsy();
+    });
+    it('should return false for null', () => {
+        expect(isNonEmptyObject(null)).toBeFalsy();
+    });
+    it('should return false for undefined', () => {
+        expect(isNonEmptyObject(undefined)).toBeFalsy();
+    });
+    it('should return false for empty object', () => {
+        expect(isNonEmptyObject({})).toBeFalsy();
+    });
+    it('should return true for non-empty object', () => {
+        expect(isNonEmptyObject({ id: 1 })).toBeTruthy();
+    });
+});
+describe('merge', () => {
+    test('Empty array', () => {
+        const result = merge([]);
+        expect(result).toEqual({});
+    });
+    it('Array with non-objects', () => {
+        const input = ['string1', 42, true];
+        const result = merge(input);
+        expect(result).toEqual({});
+    });
+    it('Array with objects and non-objects', () => {
+        const obj1 = { key1: 'value1' };
+        const obj2 = { key2: 'value2' };
+        const input = [obj1, 'string1', 42, obj2, true];
+        const result = merge(input);
+        expect(result).toEqual({ key1: 'value1', key2: 'value2' });
+    });
+    test('Array with empty objects', () => {
+        const result = merge([{}, {}, {}]);
+        expect(result).toEqual({});
+    });
+    test('Array with objects without duplicated properties', () => {
+        const result = merge([{ a: 1 }, { b: 2 }, { c: 3 }]);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+    test('Array with objects with duplicated properties and override=false', () => {
+        const result = merge([{ a: 1 }, { a: 2 }, { a: 3 }], false);
+        expect(result).toEqual({ a: 1 });
+    });
+    test('Array with objects with duplicated properties and override=true', () => {
+        const result = merge([{ a: 1 }, { a: 2 }, { a: 3 }], true);
+        expect(result).toEqual({ a: 3 });
+    });
+});
+describe('modifyKeys', () => {
+    describe('modifyKeys', () => {
+        it('should modify the keys of the object', () => {
+            const input = { id: 1, name: 'John' };
+            const callback = (key) => ('' + key).toUpperCase();
+            const result = modifyKeys(input, callback);
+            expect(result).toEqual({ ID: 1, NAME: 'John' });
+        });
+        it('should handle an empty object', () => {
+            const input = {};
+            const callback = (key) => ('' + key).toUpperCase();
+            const result = modifyKeys(input, callback);
+            expect(result).toEqual({});
+        });
+        it('should handle an object with non-string keys', () => {
+            const input = { 1: 'one', 2: 'two', 3: 'three' };
+            const callback = (key) => key + '_new';
+            const result = modifyKeys(input, callback);
+            expect(result).toEqual({ '1_new': 'one', '2_new': 'two', '3_new': 'three' });
+        });
+        it('should modify the keys based on the callback function', () => {
+            const input = { id: 1, name: 'John', age: 30 };
+            const callback = (key) => key + '_new';
+            const result = modifyKeys(input, callback);
+            expect(result).toEqual({ id_new: 1, name_new: 'John', age_new: 30 });
+        });
+        it('should not modify the original object', () => {
+            const input = { id: 1, name: 'John' };
+            const callback = (key) => ('' + key).toUpperCase();
+            const result = modifyKeys(input, callback);
+            expect(result).toEqual({ ID: 1, NAME: 'John' });
+            expect(input).toEqual({ id: 1, name: 'John' });
+        });
+        it('should modify the keys of an object', () => {
+            const obj = { a: 1, b: 2, c: 3 };
+            const callback = (key) => ('' + key).toUpperCase();
+            const result = modifyKeys(obj, callback);
+            expect(result).toEqual({ A: 1, B: 2, C: 3 });
+        });
+        it('should handle an empty object', () => {
+            const obj = {};
+            const callback = (key) => ('' + key).toUpperCase();
+            const result = modifyKeys(obj, callback);
+            expect(result).toEqual({});
+        });
+        it('should throw an error if the second argument is not a function', () => {
+            const obj = { a: 1, b: 2, c: 3 };
+            const callback = 'not a function';
+            expect(() => modifyKeys(obj, callback)).toThrow(TypeError);
+        });
+        it('should handle an object with duplicate modified keys', () => {
+            const obj = { a: 1, b: 2, c: 3 };
+            const callback = (key) => 'new_key';
+            const result = modifyKeys(obj, callback, true);
+            expect(result).toEqual({ new_key: 1 });
+        });
+        it('should handle an object with duplicate modified keys if ignoreDuplicates is false', () => {
+            const obj = { a: 1, b: 2, c: 3 };
+            const callback = (key) => 'new_key';
+            const result = modifyKeys(obj, callback, false);
+            expect(result).toEqual({ new_key: 3 });
+        });
+        it('should throw an error in strict mode if given a non-object value', () => {
+            'use strict';
+            const callback = (key) => 'new_key';
+            const fn = () => { };
+            expect(() => modifyKeys(undefined, callback)).toThrow(new TypeError('Invalid type of undefined. Expected JavaScript object'));
+            expect(() => modifyKeys(123, callback)).toThrow(new TypeError('Invalid type of Number. Expected JavaScript object'));
+            expect(() => modifyKeys('string', callback)).toThrow(new TypeError('Invalid type of String. Expected JavaScript object'));
+            expect(() => modifyKeys(Symbol(), callback)).toThrow(new TypeError('Invalid type of Symbol. Expected JavaScript object'));
+            expect(() => modifyKeys(true, callback)).toThrow(new TypeError('Invalid type of Boolean. Expected JavaScript object'));
+            expect(() => modifyKeys(fn, callback)).toThrow(new TypeError('Invalid type of Function. Expected JavaScript object'));
+            expect(() => modifyKeys([], callback)).toThrow(new TypeError('Invalid type of Array. Expected JavaScript object'));
+            expect(() => modifyKeys(new Date(), callback)).toThrow(new TypeError(`Invalid type of Date. Expected JavaScript object`));
+            class MyClass {
+            }
+            expect(() => modifyKeys(new MyClass(), callback)).toThrow(new TypeError(`Invalid type of MyClass. Expected JavaScript object`));
+        });
+    });
+});

package/dist/redis/redisActions.js

@@ -1,4 +1,4 @@
-import { getRedisClient } from "./redisClient";
+import { getRedisClient } from "./redisClient.js";
 export const removeRedisKey = async (key) => {
     const redisClient = await getRedisClient();
     await redisClient.del(key);

package/dist/regex/regex.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/regex/regex.spec.js

@@ -0,0 +1,15 @@
+import { getCapturedNumber } from "./regex";
+describe('getCapturedNumber', () => {
+    it('If there is a match, correct number should be returned', () => {
+        const pattern = 'value: (\\d+)';
+        const input = 'Current value: 123;';
+        const result = getCapturedNumber(input, pattern);
+        expect(result).toBe(123);
+    });
+    it('If there is no match, undefined is returned', () => {
+        const pattern = 'value: (d+)';
+        const input = 'Current value: 123;';
+        const result = getCapturedNumber(input, pattern);
+        expect(result).toBe(undefined);
+    });
+});

package/dist/strings/strings.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/strings/strings.spec.js

@@ -0,0 +1,61 @@
+import { capitalizeFirst, clear } from './strings.js';
+describe('capitalizeFirst', () => {
+    it('should capitalize first letter of a lowercase word', () => {
+        expect(capitalizeFirst('hello')).toBe('Hello');
+    });
+    it('should not change already capitalized string', () => {
+        expect(capitalizeFirst('Hello')).toBe('Hello');
+    });
+    it('should not modify rest of the string', () => {
+        expect(capitalizeFirst('hELLO')).toBe('HELLO');
+    });
+    it('should handle empty string', () => {
+        expect(capitalizeFirst('')).toBe('');
+    });
+    it('should handle single character', () => {
+        expect(capitalizeFirst('a')).toBe('A');
+    });
+    it('should handle strings starting with non-letter', () => {
+        expect(capitalizeFirst('1hello')).toBe('1hello');
+        expect(capitalizeFirst('!test')).toBe('!test');
+    });
+    it('should handle unicode characters', () => {
+        expect(capitalizeFirst('żółw')).toBe('Żółw');
+    });
+    it('should capitalize first non-whitespace character', () => {
+        expect(capitalizeFirst(' hello')).toBe(' Hello');
+        expect(capitalizeFirst('   world')).toBe('   World');
+    });
+    it('should return string unchanged if it contains only whitespace', () => {
+        expect(capitalizeFirst('   ')).toBe('   ');
+    });
+    it('should not modify non-letter first non-whitespace character', () => {
+        expect(capitalizeFirst('   123abc')).toBe('   123abc');
+        expect(capitalizeFirst('   !test')).toBe('   !test');
+    });
+});
+describe('clear', () => {
+    test('clear should remove leading and trailing spaces', () => {
+        expect(clear('  Hello world  ')).toBe('Hello world');
+    });
+    test('clear should remove multiple spaces inside the string', () => {
+        expect(clear('Hello    world')).toBe('Hello world');
+    });
+    test('clear should return the same string if no extra spaces', () => {
+        expect(clear('Hello world')).toBe('Hello world');
+    });
+    test('clear should return empty string if input string contains only spaces', () => {
+        expect(clear('     ')).toBe('');
+    });
+    test('clear should throw an error if input is not a string', () => {
+        expect(() => {
+            clear(123);
+        }).toThrow();
+    });
+    test('clear should handle string with only one word correctly', () => {
+        expect(clear('    Hello    ')).toBe('Hello');
+    });
+    test('clear should handle empty string correctly', () => {
+        expect(clear('')).toBe('');
+    });
+});

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import type { JSONFile } from './io.js';
 import type { Range } from './math.js';
-import type { ObjectAny, ObjectPrimitives } from './objects.js';
+import type { DeepPartial, ObjectAny, ObjectPrimitives } from './objects.js';
 export type { JSONFile };
 export type { Range };
-export type { ObjectAny, ObjectPrimitives };
+export type { DeepPartial, ObjectAny, ObjectPrimitives };

package/dist/types/objects.d.ts

@@ -4,3 +4,6 @@ export type ObjectAny = {
 export type ObjectPrimitives = {
     [key: string]: string | number | boolean | null;
 };
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};

package/dist/variables/variables.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/variables/variables.spec.js

@@ -0,0 +1,239 @@
+import { isArrayOfPrimitives, isObject, isPlainObject, isPrimitive, isStringOrNumber } from './variables.js';
+describe('isArrayOfPrimitives', () => {
+    it('should return true for an array of numbers', () => {
+        expect(isArrayOfPrimitives([1, 2, 3])).toBe(true);
+    });
+    it('should return false for an empty array', () => {
+        expect(isArrayOfPrimitives([])).toBe(false);
+    });
+    it('should return true for an array of strings', () => {
+        expect(isArrayOfPrimitives(['hello', 'world'])).toBe(true);
+    });
+    it('should return false for an array containing a non-primitive value', () => {
+        expect(isArrayOfPrimitives([1, {}, 3])).toBe(false);
+    });
+    it('should return true for an array containing null and undefined values by default', () => {
+        expect(isArrayOfPrimitives([1, null, undefined])).toBe(true);
+    });
+    it('should return false for an array containing null and undefined values if includeNullAndUndefined is set to false', () => {
+        expect(isArrayOfPrimitives([1, null, undefined], false)).toBe(false);
+    });
+    it('should return true for an array containing boolean values', () => {
+        expect(isArrayOfPrimitives([true, false])).toBe(true);
+    });
+    it('should return true for an array containing mixed primitive types', () => {
+        expect(isArrayOfPrimitives([1, 'string', true, null, undefined])).toBe(true);
+    });
+    it('should return false for a non-array value', () => {
+        expect(isArrayOfPrimitives('not an array')).toBe(false);
+    });
+    it('should return false for an array containing mixed types, with a non-primitive included', () => {
+        expect(isArrayOfPrimitives([1, 'string', true, null, undefined, {}])).toBe(false);
+    });
+});
+describe('isObject', () => {
+    test('should return true for non-empty object', () => {
+        const obj = { value: 123 };
+        expect(isObject(obj)).toEqual(true);
+    });
+    test('should return true for empty object', () => {
+        expect(isObject({})).toEqual(true);
+    });
+    test('should return true for an object', () => {
+        expect(isObject({ key: 'value' })).toBe(true);
+    });
+    test('should return false for an array', () => {
+        expect(isObject([1, 2, 3])).toBe(false);
+    });
+    test('should return false for null', () => {
+        expect(isObject(null)).toBe(false);
+    });
+    test('should return false for undefined', () => {
+        expect(isObject(undefined)).toBe(false);
+    });
+    test('should return false for a string', () => {
+        expect(isObject('string')).toBe(false);
+    });
+    test('should return false for a number', () => {
+        expect(isObject(42)).toBe(false);
+    });
+    test('should return false for a boolean', () => {
+        expect(isObject(true)).toBe(false);
+        expect(isObject(false)).toBe(false);
+    });
+    test('should return false for a function', () => {
+        expect(isObject(() => { })).toBe(false);
+    });
+});
+describe('isPlainObject', () => {
+    it('should return false for undefined', () => {
+        expect(isPlainObject(undefined)).toBeFalsy();
+    });
+    it('should return false for null', () => {
+        expect(isPlainObject(null)).toBeFalsy();
+    });
+    it('should return false for boolean', () => {
+        expect(isPlainObject(true)).toBeFalsy();
+        expect(isPlainObject(false)).toBeFalsy();
+    });
+    it('should return false for number', () => {
+        expect(isPlainObject(0)).toBeFalsy();
+        expect(isPlainObject(123)).toBeFalsy();
+        expect(isPlainObject(NaN)).toBeFalsy();
+    });
+    it('should return false for string', () => {
+        expect(isPlainObject('')).toBeFalsy();
+        expect(isPlainObject('text')).toBeFalsy();
+    });
+    it('should return false for symbol', () => {
+        expect(isPlainObject(Symbol())).toBeFalsy();
+    });
+    it('should return false for bigint', () => {
+        expect(isPlainObject(BigInt(10))).toBeFalsy();
+    });
+    it('should return false for function', () => {
+        expect(isPlainObject(() => { return undefined; })).toBeFalsy();
+        expect(isPlainObject(function () { return undefined; })).toBeFalsy();
+    });
+    it('should return false for array', () => {
+        expect(isPlainObject([])).toBeFalsy();
+        expect(isPlainObject([1, 2, 3])).toBeFalsy();
+    });
+    it('should return false for Date', () => {
+        expect(isPlainObject(new Date())).toBeFalsy();
+    });
+    it('should return false for RegExp', () => {
+        expect(isPlainObject(/abc/)).toBeFalsy();
+    });
+    it('should return false for Map', () => {
+        expect(isPlainObject(new Map())).toBeFalsy();
+    });
+    it('should return false for Set', () => {
+        expect(isPlainObject(new Set())).toBeFalsy();
+    });
+    it('should return false for Error', () => {
+        expect(isPlainObject(new Error('test'))).toBeFalsy();
+    });
+    it('should return false for class instance', () => {
+        class Test {
+        }
+        expect(isPlainObject(new Test())).toBeFalsy();
+    });
+    it('should return false for object wrapper types', () => {
+        expect(isPlainObject(new String('test'))).toBeFalsy();
+        expect(isPlainObject(new Number(123))).toBeFalsy();
+        expect(isPlainObject(new Boolean(true))).toBeFalsy();
+    });
+    it('should return false for Promise', () => {
+        expect(isPlainObject(Promise.resolve())).toBeFalsy();
+    });
+    it('should return false for global objects', () => {
+        expect(isPlainObject(Math)).toBeFalsy();
+        expect(isPlainObject(JSON)).toBeFalsy();
+    });
+    it('should return true for empty object', () => {
+        expect(isPlainObject({})).toBeTruthy();
+    });
+    it('should return true for non-empty object', () => {
+        expect(isPlainObject({ a: 1 })).toBeTruthy();
+    });
+    it('should return true for object created with Object constructor', () => {
+        expect(isPlainObject(new Object())).toBeTruthy();
+    });
+    it('should return true for object with null prototype', () => {
+        expect(isPlainObject(Object.create(null))).toBeTruthy();
+    });
+    it('should return true for object of strings', () => {
+        expect(isPlainObject({ a: 'a', b: 'b' })).toBeTruthy();
+    });
+    it('should return true for object of objects', () => {
+        expect(isPlainObject({ a: new Object(), b: [] })).toBeTruthy();
+    });
+});
+describe('isPrimitive', () => {
+    test('should return true for string', () => {
+        expect(isPrimitive('Hello')).toBe(true);
+    });
+    test('should return true for number', () => {
+        expect(isPrimitive(123)).toBe(true);
+    });
+    test('should return true for boolean', () => {
+        expect(isPrimitive(true)).toBe(true);
+        expect(isPrimitive(false)).toBe(true);
+    });
+    test('should return true for null if includeNullAndUndefined is set to false', () => {
+        expect(isPrimitive(null, true)).toBe(true);
+    });
+    test('should return true for undefined if includeNullAndUndefined is set to false', () => {
+        expect(isPrimitive(undefined, true)).toBe(true);
+    });
+    test('should return false for null if includeNullAndUndefined is set to true', () => {
+        expect(isPrimitive(null, false)).toBe(false);
+    });
+    test('should return false for undefined if includeNullAndUndefined is set to true', () => {
+        expect(isPrimitive(undefined, false)).toBe(false);
+    });
+    test('should return true for symbol', () => {
+        expect(isPrimitive(Symbol('symbol'))).toBe(true);
+    });
+    test('should return false for object', () => {
+        expect(isPrimitive({})).toBe(false);
+        expect(isPrimitive({ key: 'value' })).toBe(false);
+    });
+    test('should return false for array', () => {
+        expect(isPrimitive([])).toBe(false);
+        expect(isPrimitive([1, 2, 3])).toBe(false);
+    });
+    test('should return false for function', () => {
+        expect(isPrimitive(() => { })).toBe(false);
+    });
+});
+describe('isStringOrNumber', () => {
+    test('returns false for non-empty object', () => {
+        const obj = { value: 123 };
+        expect(isStringOrNumber(obj)).toEqual(false);
+    });
+    test('returns false for empty object', () => {
+        expect(isStringOrNumber({})).toEqual(false);
+    });
+    test('should return false for an object', () => {
+        const obj = { key: 'value' };
+        expect(isStringOrNumber(obj)).toBe(false);
+    });
+    test('should return false for an array', () => {
+        const arr = [1, 2, 3];
+        expect(isStringOrNumber(arr)).toBe(false);
+    });
+    test('should return false for null', () => {
+        expect(isStringOrNumber(null)).toBe(false);
+    });
+    test('should return false for undefined', () => {
+        expect(isStringOrNumber(undefined)).toBe(false);
+    });
+    test('should return true for a non-empty string', () => {
+        expect(isStringOrNumber('string')).toBe(true);
+    });
+    test('should return true for an empty string', () => {
+        expect(isStringOrNumber('string')).toBe(true);
+    });
+    test('should return true for a positive number', () => {
+        expect(isStringOrNumber(42)).toBe(true);
+    });
+    test('should return true for a zero', () => {
+        expect(isStringOrNumber(42)).toBe(true);
+    });
+    test('should return true for a negative number', () => {
+        expect(isStringOrNumber(42)).toBe(true);
+    });
+    test('should return true for a float number', () => {
+        expect(isStringOrNumber(42.5)).toBe(true);
+    });
+    test('should return false for a boolean', () => {
+        expect(isStringOrNumber(true)).toBe(false);
+        expect(isStringOrNumber(false)).toBe(false);
+    });
+    test('should return false for a function', () => {
+        const func = () => { };
+        expect(isStringOrNumber(func)).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-fn",
-	"version": "1.2.4",
+	"version": "1.2.6",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Generic functions used in various projects",