ts-object-lite 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './object';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./object"), exports);

package/dist/object.d.ts

@@ -0,0 +1,18 @@
+export declare class ObjectUtils {
+    deepGet(obj: unknown, path: string, defaultValue?: unknown): unknown;
+    deepSet(obj: Record<string, unknown>, path: string, value: unknown): void;
+    deepClone<T>(obj: T): T;
+    merge<T extends Record<string, unknown>>(target: T, ...sources: (Partial<T> | undefined | null)[]): T;
+    omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Partial<T>;
+    pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Partial<T>;
+    isEmpty(value: unknown): boolean;
+    isEqual(a: unknown, b: unknown): boolean;
+    keys(obj: Record<string, unknown>): string[];
+    values(obj: Record<string, unknown>): unknown[];
+    entries(obj: Record<string, unknown>): [string, unknown][];
+    has(obj: Record<string, unknown>, path: string): boolean;
+    size(obj: Record<string, unknown>): number;
+    mapValues(obj: Record<string, unknown>, fn: (v: unknown, k: string) => unknown): Record<string, unknown>;
+    invert(obj: Record<string, string>): Record<string, string>;
+    clone<T>(obj: T): T;
+}

package/dist/object.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectUtils = void 0;
+class ObjectUtils {
+    deepGet(obj, path, defaultValue) {
+        if (!obj || !path)
+            return defaultValue;
+        const keys = path.split('.');
+        let result = obj;
+        for (const key of keys) {
+            if (result === null || result === undefined)
+                return defaultValue;
+            result = result[key];
+        }
+        return result ?? defaultValue;
+    }
+    deepSet(obj, path, value) {
+        const keys = path.split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!(keys[i] in current) || current[keys[i]] === null)
+                current[keys[i]] = {};
+            current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = value;
+    }
+    deepClone(obj) {
+        if (obj === null || typeof obj !== 'object')
+            return obj;
+        if (obj instanceof Date)
+            return new Date(obj.getTime());
+        if (Array.isArray(obj))
+            return obj.map(item => this.deepClone(item));
+        const cloned = {};
+        for (const key in obj)
+            cloned[key] = this.deepClone(obj[key]);
+        return cloned;
+    }
+    merge(target, ...sources) {
+        for (const source of sources) {
+            if (!source)
+                continue;
+            for (const key of Object.keys(source)) {
+                const tv = target[key], sv = source[key];
+                if (tv && typeof tv === 'object' && sv && typeof sv === 'object' && !Array.isArray(tv) && !Array.isArray(sv)) {
+                    target[key] = this.merge(tv, sv);
+                }
+                else {
+                    target[key] = sv;
+                }
+            }
+        }
+        return target;
+    }
+    omit(obj, keys) {
+        const result = { ...obj };
+        keys.forEach(k => delete result[k]);
+        return result;
+    }
+    pick(obj, keys) {
+        const result = {};
+        keys.forEach(k => { if (k in obj)
+            result[k] = obj[k]; });
+        return result;
+    }
+    isEmpty(value) {
+        if (value === null || value === undefined)
+            return true;
+        if (typeof value === 'string')
+            return value.trim().length === 0;
+        if (Array.isArray(value))
+            return value.length === 0;
+        if (typeof value === 'object')
+            return Object.keys(value).length === 0;
+        return false;
+    }
+    isEqual(a, b) {
+        if (a === b)
+            return true;
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object')
+            return false;
+        const ak = Object.keys(a), bk = Object.keys(b);
+        return ak.length === bk.length && ak.every(k => this.isEqual(a[k], b[k]));
+    }
+    keys(obj) { return Object.keys(obj); }
+    values(obj) { return Object.values(obj); }
+    entries(obj) { return Object.entries(obj); }
+    has(obj, path) { return this.deepGet(obj, path) !== undefined; }
+    size(obj) { return Object.keys(obj).length; }
+    mapValues(obj, fn) {
+        const result = {};
+        for (const k of Object.keys(obj))
+            result[k] = fn(obj[k], k);
+        return result;
+    }
+    invert(obj) {
+        const result = {};
+        for (const k of Object.keys(obj))
+            result[obj[k]] = k;
+        return result;
+    }
+    clone(obj) { return this.deepClone(obj); }
+}
+exports.ObjectUtils = ObjectUtils;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "ts-object-lite",
+  "version": "1.0.0",
+  "description": "Lightweight, type-safe object utility library for web developers",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "keywords": ["utils", "typescript", "object", "helpers", "lite"],
+  "author": "Gaurang Mody - G8X",
+  "license": "MIT"
+}