@naturalcycles/js-lib 15.9.1 → 15.10.0

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

@@ -1,5 +1,5 @@
 import type { MutateOptions } from '../array/array.util.js';
-import type { AnyObject, KeyValueTuple, ObjectMapper, ObjectPredicate, Reviver, ValueOf } from '../types.js';
+import type { AnyObject, KeyValueTuple, ObjectMapper, ObjectPredicate, Reviver, StringMap, ValueOf } from '../types.js';
 import { SKIP } from '../types.js';
 /**
  * Returns clone of `obj` with only `props` preserved.
@@ -93,6 +93,18 @@ export declare function _objectNullValuesToUndefined<T extends AnyObject>(obj: T
  * Deep copy object (by json parse/stringify, since it has unbeatable performance+simplicity combo).
  */
 export declare function _deepCopy<T>(o: T, reviver?: Reviver): T;
+/**
+ * Performance-optimized implementation of merging two objects
+ * without mutating any of them.
+ * (if you are allowed to mutate - there can be a faster implementation).
+ *
+ * Gives ~40% speedup with map sizes between 10 and 100k items,
+ * compared to {...obj1, ...obj2} or Object.assign({}, obj1, obj2).
+ *
+ * Only use it in hot paths that are known to be performance bottlenecks,
+ * otherwise it's not worth it (use normal object spread then).
+ */
+export declare function _mergeObjects<T>(obj1: StringMap<T>, obj2: StringMap<T>): StringMap<T>;
 /**
  * Returns `undefined` if it's empty (according to `_isEmpty()` specification),
  * otherwise returns the original object.

package/dist/object/object.util.js

@@ -192,6 +192,25 @@ export function _objectNullValuesToUndefined(obj, opt = {}) {
 export function _deepCopy(o, reviver) {
     return JSON.parse(JSON.stringify(o), reviver);
 }
+/**
+ * Performance-optimized implementation of merging two objects
+ * without mutating any of them.
+ * (if you are allowed to mutate - there can be a faster implementation).
+ *
+ * Gives ~40% speedup with map sizes between 10 and 100k items,
+ * compared to {...obj1, ...obj2} or Object.assign({}, obj1, obj2).
+ *
+ * Only use it in hot paths that are known to be performance bottlenecks,
+ * otherwise it's not worth it (use normal object spread then).
+ */
+export function _mergeObjects(obj1, obj2) {
+    const map = {};
+    for (const k of Object.keys(obj1))
+        map[k] = obj1[k];
+    for (const k of Object.keys(obj2))
+        map[k] = obj2[k];
+    return map;
+}
 /**
  * Returns `undefined` if it's empty (according to `_isEmpty()` specification),
  * otherwise returns the original object.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.9.1",
+  "version": "15.10.0",
   "dependencies": {
     "tslib": "^2",
     "zod": "^3"

package/src/object/object.util.ts

@@ -6,6 +6,7 @@ import type {
   ObjectMapper,
   ObjectPredicate,
   Reviver,
+  StringMap,
   ValueOf,
 } from '../types.js'
 import { _objectEntries, SKIP } from '../types.js'
@@ -246,6 +247,24 @@ export function _deepCopy<T>(o: T, reviver?: Reviver): T {
   return JSON.parse(JSON.stringify(o), reviver)
 }
 
+/**
+ * Performance-optimized implementation of merging two objects
+ * without mutating any of them.
+ * (if you are allowed to mutate - there can be a faster implementation).
+ *
+ * Gives ~40% speedup with map sizes between 10 and 100k items,
+ * compared to {...obj1, ...obj2} or Object.assign({}, obj1, obj2).
+ *
+ * Only use it in hot paths that are known to be performance bottlenecks,
+ * otherwise it's not worth it (use normal object spread then).
+ */
+export function _mergeObjects<T>(obj1: StringMap<T>, obj2: StringMap<T>): StringMap<T> {
+  const map: StringMap<T> = {}
+  for (const k of Object.keys(obj1)) map[k] = obj1[k]
+  for (const k of Object.keys(obj2)) map[k] = obj2[k]
+  return map
+}
+
 /**
  * Returns `undefined` if it's empty (according to `_isEmpty()` specification),
  * otherwise returns the original object.