@jlhv/object-helper/dist/index.js

A simple utility library for object manipulation.

"use strict";
/**
 * Object Helper Library
 * Provides utility functions for object operations.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.isEmpty = isEmpty;
exports.merge = merge;
exports.deepClone = deepClone;
exports.pick = pick;
exports.omit = omit;
exports.isEqual = isEqual;
exports.hasNested = hasNested;
exports.getNested = getNested;
exports.setNested = setNested;
exports.invert = invert;
exports.toPairs = toPairs;
exports.fromPairs = fromPairs;
exports.freeze = freeze;
exports.mapValues = mapValues;
exports.filter = filter;
exports.deepMerge = deepMerge;
/** Checks if an object is empty. */
function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}
/** Merges two objects without modifying the originals. */
function merge(obj1, obj2) {
    const result = Object.assign({}, obj1);
    for (const key in obj2) {
        if (Object.prototype.hasOwnProperty.call(obj2, key)) {
            result[key] = obj2[key];
        }
    }
    return result;
}
/** Deep clones an object. */
function deepClone(obj) {
    return JSON.parse(JSON.stringify(obj));
}
/** Picks specific keys from an object. */
function pick(obj, keys) {
    const result = {};
    for (const key of keys) {
        if (key in obj) {
            result[key] = obj[key];
        }
    }
    return result;
}
/** Omits specific keys from an object. */
function omit(obj, keys) {
    const result = Object.assign({}, obj);
    for (const key of keys) {
        delete result[key];
    }
    return result;
}
/** Checks if two objects are equal (shallow comparison). */
function isEqual(obj1, obj2) {
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);
    if (keys1.length !== keys2.length)
        return false;
    for (const key of keys1) {
        if (obj1[key] !== obj2[key])
            return false;
    }
    return true;
}
/** Checks if an object has a nested property. */
function hasNested(obj, path) {
    const keys = path.split(".");
    let current = obj;
    for (const key of keys) {
        if (!current || !Object.prototype.hasOwnProperty.call(current, key)) {
            return false;
        }
        current = current[key];
    }
    return true;
}
/** Gets a nested property value from an object safely. */
function getNested(obj, path, defaultValue) {
    const keys = path.split(".");
    let current = obj;
    for (const key of keys) {
        if (!current || !Object.prototype.hasOwnProperty.call(current, key)) {
            return defaultValue;
        }
        current = current[key];
    }
    return current;
}
/** Sets a nested property value in an object. */
function setNested(obj, path, value) {
    const keys = path.split(".");
    let current = obj;
    while (keys.length > 1) {
        const key = keys.shift();
        if (!Object.prototype.hasOwnProperty.call(current, key) ||
            typeof current[key] !== "object") {
            current[key] = {};
        }
        current = current[key];
    }
    current[keys[0]] = value;
}
/** Inverts an object's keys and values. */
function invert(obj) {
    const result = {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            result[String(obj[key])] = key;
        }
    }
    return result;
}
/** Converts an object to an array of key-value pairs. */
function toPairs(obj) {
    return Object.entries(obj);
}
/** Converts an array of key-value pairs to an object. */
function fromPairs(pairs) {
    const result = {};
    for (const [key, value] of pairs) {
        result[key] = value;
    }
    return result;
}
/** Freezes an object to prevent modifications. */
function freeze(obj) {
    return Object.freeze(obj);
}
/** Maps over object values and returns a new object. */
function mapValues(obj, callback) {
    const result = {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            result[key] = callback(obj[key], key);
        }
    }
    return result;
}
/** Filters object properties based on a predicate function. */
function filter(obj, predicate) {
    const result = {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key) &&
            predicate(obj[key], key)) {
            result[key] = obj[key];
        }
    }
    return result;
}
/** Deep merges two objects. */
function deepMerge(obj1, obj2) {
    const result = Object.assign({}, obj1);
    for (const key in obj2) {
        if (Object.prototype.hasOwnProperty.call(obj2, key)) {
            if (typeof obj2[key] === "object" &&
                !Array.isArray(obj2[key]) &&
                obj2[key] !== null) {
                result[key] = deepMerge(result[key] || {}, obj2[key]);
            }
            else {
                result[key] = obj2[key];
            }
        }
    }
    return result;
}