xypriss 9.12.11 → 9.12.13

package/dist/esm/src/xhsc/utils/ObjectUtils.js

@@ -1,9 +1,455 @@
 import { XStringify } from 'xypriss-security';
 
+class ObjectWrapper {
+    constructor(obj) {
+        this.current = obj;
+    }
+    /**
+     * **value**
+     *
+     * Unwraps and returns the underlying plain object held by this wrapper.
+     * Call this at the end of a chain to get back a normal object.
+     *
+     * @returns The current wrapped object.
+     *
+     * @example
+     * ```ts
+     * const obj = __sys__.utils.obj.of({ a: 1 });
+     * obj.value(); // { a: 1 }
+     * ```
+     */
+    value() {
+        return this.current;
+    }
+    /**
+     * **raw**
+     *
+     * Alias for {@link value}. Useful when `value` reads awkwardly in context.
+     *
+     * @returns The current wrapped object.
+     */
+    raw() {
+        return this.current;
+    }
+    /**
+     * **clone**
+     *
+     * Deep-clones the wrapped object (via `XStringify`) and continues
+     * the chain on the cloned copy, leaving the original untouched.
+     *
+     * @returns `this`, now wrapping a deep copy of the previous value.
+     *
+     * @example
+     * ```ts
+     * const source = { nested: { count: 1 } };
+     * const obj = __sys__.utils.obj.of(source).clone();
+     * obj.value().nested.count = 99;
+     * // source.nested.count is still 1
+     * ```
+     */
+    clone() {
+        this.current = JSON.parse(XStringify(this.current));
+        return this;
+    }
+    /**
+     * **pick**
+     *
+     * Narrows the wrapped object down to only the given keys.
+     *
+     * @param keys - The keys to keep.
+     * @returns `this`, now wrapping only the picked keys.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: 1, b: 2, c: 3 }).pick(["a", "c"]).value();
+     * // { a: 1, c: 3 }
+     * ```
+     */
+    pick(keys) {
+        const result = keys.reduce((acc, key) => {
+            if (key in this.current)
+                acc[key] = this.current[key];
+            return acc;
+        }, {});
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **omit**
+     *
+     * Removes the given keys from the wrapped object.
+     *
+     * @param keys - The keys to remove.
+     * @returns `this`, now wrapping the object without those keys.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: 1, b: 2, c: 3 }).omit(["b"]).value();
+     * // { a: 1, c: 3 }
+     * ```
+     */
+    omit(keys) {
+        const result = { ...this.current };
+        keys.forEach((key) => delete result[key]);
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **isEmpty**
+     *
+     * Checks whether the wrapped object has no own enumerable keys.
+     * This is a terminal read (does not return the wrapper), since it
+     * yields a boolean rather than an object.
+     *
+     * @returns `true` if the object has no own keys.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({}).isEmpty(); // true
+     * ```
+     */
+    isEmpty() {
+        return Object.keys(this.current).length === 0;
+    }
+    /**
+     * **flatten**
+     *
+     * Collapses the wrapped object's nested structure into flat
+     * dot-notation (or custom separator) keys.
+     *
+     * @param separator - Path separator (default: `"."`).
+     * @returns A new wrapper around the flattened object.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: { b: 1 } }).flatten().value();
+     * // { "a.b": 1 }
+     * ```
+     */
+    flatten(separator = ".") {
+        const result = {};
+        const recurse = (current, path = "") => {
+            for (const [key, val] of Object.entries(current)) {
+                const newPath = path ? `${path}${separator}${key}` : key;
+                if (val &&
+                    typeof val === "object" &&
+                    !Array.isArray(val) &&
+                    Object.keys(val).length > 0) {
+                    recurse(val, newPath);
+                }
+                else {
+                    result[newPath] = val;
+                }
+            }
+        };
+        recurse(this.current);
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **unflatten**
+     *
+     * Reverses {@link flatten}, expanding dot-notation (or custom
+     * separator) keys back into a nested object.
+     *
+     * @param separator - Path separator used in the flat keys (default: `"."`).
+     * @returns A new wrapper around the nested object.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ "a.b": 1, "a.c": 2 }).unflatten().value();
+     * // { a: { b: 1, c: 2 } }
+     * ```
+     */
+    unflatten(separator = ".") {
+        const result = {};
+        for (const [flatKey, val] of Object.entries(this.current)) {
+            const parts = flatKey.split(separator);
+            let cursor = result;
+            parts.forEach((part, i) => {
+                if (i === parts.length - 1) {
+                    cursor[part] = val;
+                }
+                else {
+                    if (typeof cursor[part] !== "object" ||
+                        cursor[part] === null) {
+                        cursor[part] = {};
+                    }
+                    cursor = cursor[part];
+                }
+            });
+        }
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **merge**
+     *
+     * Deep-merges one or more source objects into the wrapped object.
+     * Plain object values are merged recursively; arrays and primitives
+     * are overwritten by the last source that defines them.
+     *
+     * @param sources - One or more partial objects to merge in.
+     * @returns `this`, now wrapping the merged result.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: 1, nested: { x: 1 } })
+     *   .merge({ nested: { y: 2 } })
+     *   .value();
+     * // { a: 1, nested: { x: 1, y: 2 } }
+     * ```
+     */
+    merge(...sources) {
+        const isPlainObject = (val) => !!val && typeof val === "object" && !Array.isArray(val);
+        const deepMerge = (target, source) => {
+            for (const key of Object.keys(source)) {
+                if (isPlainObject(source[key]) && isPlainObject(target[key])) {
+                    deepMerge(target[key], source[key]);
+                }
+                else {
+                    target[key] = source[key];
+                }
+            }
+            return target;
+        };
+        this.current = sources.reduce((acc, src) => deepMerge(acc, src), this.current);
+        return this;
+    }
+    /**
+     * **mapValues**
+     *
+     * Transforms every value of the wrapped object using `fn`, keeping
+     * the same keys.
+     *
+     * @param fn - Mapping function receiving `(value, key)`.
+     * @returns A new wrapper around the transformed object.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: 1, b: 2 }).mapValues((v) => v * 10).value();
+     * // { a: 10, b: 20 }
+     * ```
+     */
+    mapValues(fn) {
+        const result = {};
+        for (const key of Object.keys(this.current)) {
+            result[key] = fn(this.current[key], key);
+        }
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **mapKeys**
+     *
+     * Transforms every key of the wrapped object using `fn`, keeping
+     * the same values.
+     *
+     * @param fn - Mapping function receiving `(key, value)`. Must return a string.
+     * @returns A new wrapper around the object with renamed keys.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: 1, b: 2 })
+     *   .mapKeys((k) => k.toUpperCase())
+     *   .value();
+     * // { A: 1, B: 2 }
+     * ```
+     */
+    mapKeys(fn) {
+        const result = {};
+        for (const key of Object.keys(this.current)) {
+            result[fn(key, this.current[key])] = this.current[key];
+        }
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **filter**
+     *
+     * Keeps only the key-value pairs for which `predicate` returns `true`.
+     *
+     * @param predicate - Function receiving `(value, key)`.
+     * @returns A new wrapper around the filtered object.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: 1, b: 2, c: 3 })
+     *   .filter((v) => v > 1)
+     *   .value();
+     * // { b: 2, c: 3 }
+     * ```
+     */
+    filter(predicate) {
+        const result = {};
+        for (const key of Object.keys(this.current)) {
+            if (predicate(this.current[key], key)) {
+                result[key] = this.current[key];
+            }
+        }
+        return new ObjectWrapper(result);
+    }
+    /**
+     * **keys**
+     *
+     * Returns the own enumerable keys of the wrapped object.
+     * This is a terminal read.
+     *
+     * @returns Array of keys.
+     */
+    keys() {
+        return Object.keys(this.current);
+    }
+    /**
+     * **values**
+     *
+     * Returns the own enumerable values of the wrapped object.
+     * This is a terminal read.
+     *
+     * @returns Array of values.
+     */
+    values() {
+        return Object.values(this.current);
+    }
+    /**
+     * **entries**
+     *
+     * Returns the own enumerable `[key, value]` pairs of the wrapped object.
+     * This is a terminal read.
+     *
+     * @returns Array of `[key, value]` tuples.
+     */
+    entries() {
+        return Object.entries(this.current);
+    }
+    /**
+     * **has**
+     *
+     * Checks whether the wrapped object has the given own key.
+     * This is a terminal read.
+     *
+     * @param key - The key to check.
+     * @returns `true` if the key exists on the object.
+     */
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this.current, key);
+    }
+    /**
+     * **get**
+     *
+     * Safely reads a possibly-nested value using dot-notation path,
+     * returning `fallback` if any part of the path is missing.
+     * This is a terminal read.
+     *
+     * @param path - Dot-notation path (e.g. `"a.b.c"`).
+     * @param fallback - Value returned if the path can't be resolved.
+     * @returns The resolved value or the fallback.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: { b: { c: 42 } } }).get("a.b.c"); // 42
+     * __sys__.utils.obj.of({ a: {} }).get("a.b.c", "missing");    // "missing"
+     * ```
+     */
+    get(path, fallback = undefined) {
+        const parts = path.split(".");
+        let cursor = this.current;
+        for (const part of parts) {
+            if (cursor === null || cursor === undefined)
+                return fallback;
+            cursor = cursor[part];
+        }
+        return cursor === undefined ? fallback : cursor;
+    }
+    /**
+     * **set**
+     *
+     * Sets a possibly-nested value using dot-notation path, creating
+     * intermediate objects as needed.
+     *
+     * @param path - Dot-notation path (e.g. `"a.b.c"`).
+     * @param value - The value to set.
+     * @returns `this`, with the value set at the given path.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of<any>({}).set("a.b.c", 42).value();
+     * // { a: { b: { c: 42 } } }
+     * ```
+     */
+    set(path, value) {
+        const parts = path.split(".");
+        let cursor = this.current;
+        parts.forEach((part, i) => {
+            if (i === parts.length - 1) {
+                cursor[part] = value;
+            }
+            else {
+                if (typeof cursor[part] !== "object" || cursor[part] === null) {
+                    cursor[part] = {};
+                }
+                cursor = cursor[part];
+            }
+        });
+        return this;
+    }
+    /**
+     * **equals**
+     *
+     * Performs a deep structural equality check between the wrapped
+     * object and `other`. This is a terminal read.
+     *
+     * @param other - The object to compare against.
+     * @returns `true` if both objects are deeply equal.
+     *
+     * @example
+     * ```ts
+     * __sys__.utils.obj.of({ a: { b: 1 } }).equals({ a: { b: 1 } }); // true
+     * ```
+     */
+    equals(other) {
+        return __sys__.utils.obj.deepEqual(this.current, other);
+    }
+}
 /**
  * **ObjectUtils — XyPriss Object Utilities**
+ *
+ * All original methods remain fully supported and are **not deprecated**;
+ * they are the right choice for one-off, single-call operations. For
+ * chaining several operations on the same object without repeating it as
+ * an argument each time, use {@link __sys__.utils.obj.of} to get a fluent
+ * {@link ObjectWrapper} instance instead:
+ *
+ * @example
+ * ```ts
+ * // Classic style (still fully supported):
+ * const utils = new ObjectUtils();
+ * utils.omit(utils.pick(obj, ["a", "b", "c"]), ["c"]);
+ *
+ * // Fluent style (new, optional):
+ * const result = __sys__.utils.obj.of(obj)
+ *   .pick(["a", "b", "c"])
+ *   .omit(["c"])
+ *   .value();
+ * ```
  */
 class ObjectUtils {
+    /**
+     * **of**
+     *
+     * Wraps `obj` in a chainable {@link ObjectWrapper}, so multiple
+     * operations can be applied in sequence without re-declaring the
+     * object as an argument each time.
+     *
+     * This does not mutate or replace the classic API — it's an
+     * additive convenience entry point.
+     *
+     * @param obj - The object to wrap.
+     * @returns An {@link ObjectWrapper} bound to `obj`.
+     *
+     * @example
+     * ```ts
+     * const obj = __sys__.utils.obj.of({ a: 1, b: 2, c: 3 });
+     * const picked = obj.pick(["a", "b"]).value(); // { a: 1, b: 2 }
+     * ```
+     */
+    static of(obj) {
+        return new ObjectWrapper(obj);
+    }
     /**
      * **Deep Clone an Object**
      *
@@ -95,6 +541,12 @@ class ObjectUtils {
      * @param obj - The object to flatten.
      * @param separator - Optional path separator (default: `"."`).
      * @returns A shallow object with path-based keys.
+     *
+     * @example
+     * ```ts
+     * utils.flattenObject({ a: { b: 1, c: { d: 2 } } });
+     * // { "a.b": 1, "a.c.d": 2 }
+     * ```
      */
     flattenObject(obj, separator = ".") {
         const result = {};
@@ -115,6 +567,42 @@ class ObjectUtils {
         recurse(obj);
         return result;
     }
+    /**
+     * **unflattenObject**
+     *
+     * Reverses {@link flattenObject}, expanding dot-notation (or custom
+     * separator) keys back into a nested object structure.
+     *
+     * @param obj - The flat object to expand.
+     * @param separator - Path separator used in the flat keys (default: `"."`).
+     * @returns A nested object reconstructed from the flat keys.
+     *
+     * @example
+     * ```ts
+     * utils.unflattenObject({ "a.b": 1, "a.c.d": 2 });
+     * // { a: { b: 1, c: { d: 2 } } }
+     * ```
+     */
+    unflattenObject(obj, separator = ".") {
+        const result = {};
+        for (const [flatKey, val] of Object.entries(obj)) {
+            const parts = flatKey.split(separator);
+            let cursor = result;
+            parts.forEach((part, i) => {
+                if (i === parts.length - 1) {
+                    cursor[part] = val;
+                }
+                else {
+                    if (typeof cursor[part] !== "object" ||
+                        cursor[part] === null) {
+                        cursor[part] = {};
+                    }
+                    cursor = cursor[part];
+                }
+            });
+        }
+        return result;
+    }
     /**
      * **parse**
      *
@@ -124,6 +612,12 @@ class ObjectUtils {
      * @param json The JSON string to parse.
      * @param fallback The fallback value to return on failure.
      * @returns The parsed object or the fallback value.
+     *
+     * @example
+     * ```ts
+     * utils.parse('{"a":1}');       // { a: 1 }
+     * utils.parse("not json", {});  // {}
+     * ```
      */
     parse(json, fallback = null) {
         try {
@@ -133,7 +627,344 @@ class ObjectUtils {
             return fallback;
         }
     }
+    /**
+     * **merge**
+     *
+     * Deep-merges one or more source objects into a copy of `target`.
+     * Plain object values are merged recursively; arrays and primitive
+     * values are overwritten by the last source that defines them.
+     * The original `target` and `sources` are never mutated.
+     *
+     * @param target - The base object.
+     * @param sources - One or more objects to merge into the base.
+     * @returns A new object containing the deep-merged result.
+     *
+     * @example
+     * ```ts
+     * utils.merge({ a: 1, nested: { x: 1 } }, { nested: { y: 2 } });
+     * // { a: 1, nested: { x: 1, y: 2 } }
+     * ```
+     */
+    merge(target, ...sources) {
+        const isPlainObject = (val) => !!val && typeof val === "object" && !Array.isArray(val);
+        const deepMerge = (t, s) => {
+            for (const key of Object.keys(s)) {
+                if (isPlainObject(s[key]) && isPlainObject(t[key])) {
+                    deepMerge(t[key], s[key]);
+                }
+                else {
+                    t[key] = s[key];
+                }
+            }
+            return t;
+        };
+        const base = JSON.parse(XStringify(target));
+        return sources.reduce((acc, src) => deepMerge(acc, src), base);
+    }
+    /**
+     * **mapValues**
+     *
+     * Builds a new object by transforming every value of `obj` with `fn`,
+     * keeping the same keys.
+     *
+     * @param obj - The source object.
+     * @param fn - Mapping function receiving `(value, key)`.
+     * @returns A new object with transformed values.
+     *
+     * @example
+     * ```ts
+     * utils.mapValues({ a: 1, b: 2 }, (v) => v * 10);
+     * // { a: 10, b: 20 }
+     * ```
+     */
+    mapValues(obj, fn) {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = fn(obj[key], key);
+        }
+        return result;
+    }
+    /**
+     * **mapKeys**
+     *
+     * Builds a new object by transforming every key of `obj` with `fn`,
+     * keeping the same values.
+     *
+     * @param obj - The source object.
+     * @param fn - Mapping function receiving `(key, value)`. Must return a string.
+     * @returns A new object with renamed keys.
+     *
+     * @example
+     * ```ts
+     * utils.mapKeys({ a: 1, b: 2 }, (k) => k.toUpperCase());
+     * // { A: 1, B: 2 }
+     * ```
+     */
+    mapKeys(obj, fn) {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[fn(key, obj[key])] = obj[key];
+        }
+        return result;
+    }
+    /**
+     * **filter**
+     *
+     * Builds a new object containing only the key-value pairs of `obj`
+     * for which `predicate` returns `true`.
+     *
+     * @param obj - The source object.
+     * @param predicate - Function receiving `(value, key)`.
+     * @returns A new, filtered object.
+     *
+     * @example
+     * ```ts
+     * utils.filter({ a: 1, b: 2, c: 3 }, (v) => v > 1);
+     * // { b: 2, c: 3 }
+     * ```
+     */
+    filter(obj, predicate) {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            if (predicate(obj[key], key)) {
+                result[key] = obj[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * **get**
+     *
+     * Safely reads a possibly-nested value from `obj` using a dot-notation
+     * path, returning `fallback` if any part of the path is missing.
+     *
+     * @param obj - The source object.
+     * @param path - Dot-notation path (e.g. `"a.b.c"`).
+     * @param fallback - Value returned if the path can't be resolved.
+     * @returns The resolved value or the fallback.
+     *
+     * @example
+     * ```ts
+     * utils.get({ a: { b: { c: 42 } } }, "a.b.c");        // 42
+     * utils.get({ a: {} }, "a.b.c", "missing");            // "missing"
+     * ```
+     */
+    get(obj, path, fallback = undefined) {
+        const parts = path.split(".");
+        let cursor = obj;
+        for (const part of parts) {
+            if (cursor === null || cursor === undefined)
+                return fallback;
+            cursor = cursor[part];
+        }
+        return cursor === undefined ? fallback : cursor;
+    }
+    /**
+     * **set**
+     *
+     * Returns a new object equal to `obj` but with a possibly-nested value
+     * set at `path` (dot-notation), creating intermediate objects as needed.
+     * The original `obj` is not mutated.
+     *
+     * @param obj - The source object.
+     * @param path - Dot-notation path (e.g. `"a.b.c"`).
+     * @param value - The value to set.
+     * @returns A new object with the value set at the given path.
+     *
+     * @example
+     * ```ts
+     * utils.set({}, "a.b.c", 42);
+     * // { a: { b: { c: 42 } } }
+     * ```
+     */
+    set(obj, path, value) {
+        const clone = JSON.parse(XStringify(obj));
+        const parts = path.split(".");
+        let cursor = clone;
+        parts.forEach((part, i) => {
+            if (i === parts.length - 1) {
+                cursor[part] = value;
+            }
+            else {
+                if (typeof cursor[part] !== "object" || cursor[part] === null) {
+                    cursor[part] = {};
+                }
+                cursor = cursor[part];
+            }
+        });
+        return clone;
+    }
+    /**
+     * **has**
+     *
+     * Checks whether `obj` has the given own key (shortcut over
+     * `Object.prototype.hasOwnProperty`).
+     *
+     * @param obj - The object to inspect.
+     * @param key - The key to check.
+     * @returns `true` if the key exists as an own property.
+     *
+     * @example
+     * ```ts
+     * utils.has({ a: 1 }, "a"); // true
+     * utils.has({ a: 1 }, "b"); // false
+     * ```
+     */
+    has(obj, key) {
+        return Object.prototype.hasOwnProperty.call(obj, key);
+    }
+    /**
+     * **deepEqual**
+     *
+     * Performs a deep structural equality check between two values,
+     * comparing plain objects and arrays recursively by value rather
+     * than by reference.
+     *
+     * @param a - First value.
+     * @param b - Second value.
+     * @returns `true` if both values are deeply equal.
+     *
+     * @example
+     * ```ts
+     * utils.deepEqual({ a: { b: 1 } }, { a: { b: 1 } }); // true
+     * utils.deepEqual({ a: 1 }, { a: 2 });               // false
+     * ```
+     */
+    static deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a !== typeof b)
+            return false;
+        if (a === null || b === null)
+            return a === b;
+        if (typeof a !== "object")
+            return false;
+        if (Array.isArray(a) || Array.isArray(b)) {
+            if (!Array.isArray(a) || !Array.isArray(b))
+                return false;
+            if (a.length !== b.length)
+                return false;
+            return a.every((item, i) => __sys__.utils.obj.deepEqual(item, b[i]));
+        }
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key) => __sys__.utils.obj.deepEqual(a[key], b[key]));
+    }
+    /**
+     * **deepEqual** (instance method)
+     *
+     * Instance-bound convenience wrapper around the static
+     * {@link __sys__.utils.obj.deepEqual}, for callers already holding an
+     * `ObjectUtils` instance.
+     *
+     * @param a - First value.
+     * @param b - Second value.
+     * @returns `true` if both values are deeply equal.
+     */
+    deepEqual(a, b) {
+        return __sys__.utils.obj.deepEqual(a, b);
+    }
+    /**
+     * **invert**
+     *
+     * Swaps keys and values: returns a new object where each original
+     * value (stringified) becomes a key, and each original key becomes
+     * its value. If multiple keys share a value, the last one wins.
+     *
+     * @param obj - The source object. Values are coerced to strings for keys.
+     * @returns A new object with keys and values swapped.
+     *
+     * @example
+     * ```ts
+     * utils.invert({ a: "x", b: "y" });
+     * // { x: "a", y: "b" }
+     * ```
+     */
+    invert(obj) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[String(value)] = key;
+        }
+        return result;
+    }
+    /**
+     * **defaults**
+     *
+     * Returns a new object built from `obj`, filling in any keys that are
+     * `undefined` with the corresponding value from `defaultsObj`.
+     * Does not overwrite keys that already have a defined value.
+     *
+     * @param obj - The source object.
+     * @param defaultsObj - Object providing fallback values.
+     * @returns A new object with defaults applied.
+     *
+     * @example
+     * ```ts
+     * utils.defaults({ a: 1, b: undefined }, { b: 2, c: 3 });
+     * // { a: 1, b: 2, c: 3 }
+     * ```
+     */
+    defaults(obj, defaultsObj) {
+        const result = { ...defaultsObj, ...obj };
+        for (const key of Object.keys(result)) {
+            if (result[key] === undefined && key in defaultsObj) {
+                result[key] = defaultsObj[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * **compact**
+     *
+     * Returns a new object with all keys whose value is `null` or
+     * `undefined` removed.
+     *
+     * @param obj - The source object.
+     * @returns A new object without null/undefined values.
+     *
+     * @example
+     * ```ts
+     * utils.compact({ a: 1, b: null, c: undefined, d: 0 });
+     * // { a: 1, d: 0 }
+     * ```
+     */
+    compact(obj) {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            const val = obj[key];
+            if (val !== null && val !== undefined) {
+                result[key] = val;
+            }
+        }
+        return result;
+    }
+    /**
+     * **isPlainObject**
+     *
+     * Checks whether `value` is a plain object (i.e. not `null`, not an
+     * array, not a class instance created from a custom prototype, and
+     * not a built-in like `Date`, `Map`, or `Set`).
+     *
+     * @param value - The value to check.
+     * @returns `true` if `value` is a plain object.
+     *
+     * @example
+     * ```ts
+     * utils.isPlainObject({});          // true
+     * utils.isPlainObject([]);          // false
+     * utils.isPlainObject(new Date());  // false
+     * utils.isPlainObject(null);        // false
+     * ```
+     */
+    isPlainObject(value) {
+        if (value === null || typeof value !== "object")
+            return false;
+        const proto = Object.getPrototypeOf(value);
+        return proto === Object.prototype || proto === null;
+    }
 }
 
-export { ObjectUtils };
+export { ObjectUtils, ObjectWrapper };
 //# sourceMappingURL=ObjectUtils.js.map