@pristine-ts/common 2.0.14 → 2.0.15

package/dist/types/utils/object.util.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Utilities for working with plain objects.
+ */
+export declare class ObjectUtil {
+    /**
+     * Deep-merges `sources` left-to-right into a brand-new object and returns it. This is a
+     * dependency-free replacement for `lodash.merge({}, ...sources)`, reproducing the subset
+     * of its behaviour the framework relies on when combining a class-level and a method-level
+     * route context:
+     *
+     * - plain objects are merged recursively (a key present on both sides is deep-merged, NOT
+     *   overwritten — e.g. `@responseHeader` maps from both levels are combined);
+     * - arrays are merged by index — element `i` of a later source merges onto element `i` of
+     *   the earlier one and extra elements are appended (matching lodash, which neither
+     *   concatenates nor replaces the array wholesale — e.g. `@guard`);
+     * - a source value of `undefined` never overwrites an already-present value;
+     * - every other value (primitive, function, Date, class instance, ...) from a later source
+     *   overwrites the earlier one by assignment.
+     *
+     * None of the `sources` are mutated: plain objects and arrays are cloned into a fresh
+     * target as they are merged, so the result shares no references with its inputs.
+     */
+    static deepMerge(...sources: any[]): any;
+    /**
+     * Merges the enumerable own properties of `source` into `target` in place. `target` is
+     * always an object owned by the caller (never one of the original sources), so mutating it
+     * here is safe. Non-object sources (including `undefined`/`null`) are ignored.
+     * @private
+     */
+    private static mergeInto;
+    /**
+     * Computes the merged value for a single key: recurse into arrays (by index) and plain
+     * objects, otherwise take the source value. Always returns a value owned by the target tree
+     * (source containers are cloned) so inputs are never aliased.
+     * @private
+     */
+    private static mergeValue;
+    /**
+     * True only for object literals (`{}`-style or `Object.create(null)`); false for arrays,
+     * class instances, Dates, functions, `null` and primitives — i.e. the values `deepMerge`
+     * should overwrite rather than recurse into.
+     * @private
+     */
+    private static isPlainObject;
+}

package/dist/types/utils/utils.d.ts

@@ -1,3 +1,4 @@
 export * from "./date.util";
 export * from "./enum.util";
 export * from "./metadata.util";
+export * from "./object.util";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/common",
-  "version": "2.0.14",
+  "version": "2.0.15",
   "description": "",
   "module": "dist/lib/esm/common.module.js",
   "main": "dist/lib/cjs/common.module.js",
@@ -63,5 +63,5 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "09be6feb8eeb2b0814d070e5005113f58519710b"
+  "gitHead": "22ffa953ae37cf2375403614293fed9b1afdf606"
 }