mielk-fn 1.0.2 → 1.0.4

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import arrays from './methods/arrays';
+import objects from './methods/objects';
+export { arrays, objects };

package/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objects = exports.arrays = void 0;
+const arrays_1 = __importDefault(require("./methods/arrays"));
+exports.arrays = arrays_1.default;
+const objects_1 = __importDefault(require("./methods/objects"));
+exports.objects = objects_1.default;

package/lib/methods/arrays.d.ts

@@ -0,0 +1,8 @@
+type NumberFunction = (item: any) => number;
+type StringNumberFunction = (item: any) => string | number;
+type AnyFunction = (item: any) => any;
+declare const _default: {
+    toMap: (items: any[], keyCallback: StringNumberFunction, valueFn?: AnyFunction, ignoreDuplicates?: boolean) => Map<any, any>;
+    toIndexedArray: (items: any[], callback: NumberFunction) => any[];
+};
+export default _default;

package/lib/methods/arrays.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const toMap = (items, keyCallback, valueFn = (item) => item, ignoreDuplicates = true) => {
+    const map = new Map();
+    items.forEach((item) => {
+        const key = keyCallback(item);
+        const value = valueFn ? valueFn(item) : item;
+        if (ignoreDuplicates && map.has(key)) {
+        }
+        else {
+            map.set(key, value);
+        }
+    });
+    return map;
+};
+const toIndexedArray = (items, callback) => {
+    const arr = [];
+    items.forEach((item) => {
+        // Check if item is an object and has a function named callback
+        if (typeof item === 'object' && item !== null) {
+            const index = callback(item);
+            if (typeof index !== 'number') {
+                throw new TypeError('Callback should return a number.');
+            }
+            arr[index] = item;
+        }
+    });
+    return arr;
+};
+exports.default = { toMap, toIndexedArray };

package/lib/methods/objects.d.ts

@@ -0,0 +1,12 @@
+type AnyObject = {
+    [key: string]: any;
+};
+type NumberStringFunction = (key: string, item: any) => number | string;
+declare const _default: {
+    isObject: (value: unknown) => boolean;
+    isPlainObject: (value: unknown) => boolean;
+    merge: (objects: AnyObject[], override?: boolean) => AnyObject;
+    invert: (obj: Record<string | number, string | number>) => Record<string | number, string | number>;
+    modifyKeys: (obj: AnyObject, callback: NumberStringFunction, ignoreDuplicates?: boolean) => AnyObject;
+};
+export default _default;

package/lib/methods/objects.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isObject = (value) => typeof value === 'object' && !Array.isArray(value) && value !== null;
+const isPlainObject = (value) => (value === null || value === void 0 ? void 0 : value.constructor.name) === 'Object';
+const merge = (objects, override = false) => {
+    const merged = {};
+    objects.forEach((obj) => {
+        if (isObject(obj)) {
+            const entries = Object.entries(obj);
+            entries.forEach(([key, value]) => {
+                if (!merged[key] || override)
+                    merged[key] = value;
+            });
+        }
+    });
+    return merged;
+};
+const invert = (obj) => {
+    if (!isObject(obj)) {
+        throw new Error('Invalid input: the input must be an object.');
+    }
+    const inverted = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new Error('Invalid value type: the value must be a string or a number.');
+        }
+        inverted[value] = key;
+    }
+    return inverted;
+};
+const modifyKeys = (obj, callback, ignoreDuplicates = true) => {
+    if (!isPlainObject(obj))
+        throw new TypeError(`Invalid type of ${obj === null || obj === void 0 ? void 0 : obj.constructor.name}. Expected JavaScript object`);
+    const entries = Object.entries(obj || {});
+    const result = {};
+    entries.forEach(([key, value]) => {
+        const newKey = callback(key, value);
+        if (!result.hasOwnProperty(newKey) || !ignoreDuplicates) {
+            result[newKey] = value;
+        }
+    });
+    return result;
+};
+exports.default = { isObject, isPlainObject, merge, invert, modifyKeys };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mielk-fn",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Set of helpful functions",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
-    "prepublish": "npm test",
+    "prepublishOnly": "npm test",
     "test": "jest",
     "build": "tsc"
   },

package/tests/objects.test.ts

@@ -50,7 +50,7 @@ describe('isObject', () => {
 describe('isPlainObject', () => {
 	const { isPlainObject } = objects;
 	it('should return true for plain JavaScript objects', () => {
-		expect(isPlainObject({})).toBe(false);
+		expect(isPlainObject({})).toBe(true);
 		expect(isPlainObject({ key: 'value' })).toBe(true);
 	});