inferred-types 0.55.7 → 0.55.8

package/modules/runtime/dist/index.d.ts

@@ -10838,13 +10838,13 @@ type TypeToken__Number = `::${number}`;
 type TypeToken__NumberSet = "bigInt" | `bigInt::${bigint}` | "digit" | `digit::${2 | 3 | 4}` | "integer";
 type params = string;
 type rtn = string;
-type D = TypeTokenDelimiter;
-type TypeToken__Fn = `[${params}]` | `[${params}]${D}${rtn}` | `any::${rtn}`;
-type TypeToken__Gen = `[${params}]` | `[${params}]${D}${rtn}` | `gen${D}any${D}${rtn}`;
-type TypeToken__FnSet = `withoutParams` | `withoutParams${D}${rtn}` | `booleanLogic` | `booleanLogic${D}[${params}]`;
+type D$1 = TypeTokenDelimiter;
+type TypeToken__Fn = `[${params}]` | `[${params}]${D$1}${rtn}` | `any::${rtn}`;
+type TypeToken__Gen = `[${params}]` | `[${params}]${D$1}${rtn}` | `gen${D$1}any${D$1}${rtn}`;
+type TypeToken__FnSet = `withoutParams` | `withoutParams${D$1}${rtn}` | `booleanLogic` | `booleanLogic${D$1}[${params}]`;
 type RecVariant = typeof TYPE_TOKEN_REC_VARIANTS[number];
 type RecKeyVariant = typeof TYPE_TOKEN_REC_KEY_VARIANTS[number];
-type TypeToken__Rec = `${RecVariant}${D}${RecKeyVariant}` | `${D}kv${D}${string}` | `${D}kv${D}${string}${D}${"withUnknownIndex" | "withAnyIndex"}`;
+type TypeToken__Rec = `${RecVariant}${D$1}${RecKeyVariant}` | `${D$1}kv${D$1}${string}` | `${D$1}kv${D$1}${string}${D$1}${"withUnknownIndex" | "withAnyIndex"}`;
 type TypeToken__Undefined = "";
 type TypeToken__Null = "";
 type TypeToken__Boolean = "";
@@ -13738,7 +13738,10 @@ type Mapper<TFrom extends AnyObject, TTo> = (<TInput extends TFrom>(from: TInput
 declare function createObjectMap<TFrom extends AnyObject, TTo extends AnyObject>(): <TMap extends ObjectMap<TFrom, TTo>>(map: TMap) => ObjectMapConversion<TFrom, TTo, TMap>;
 declare function createMapper<TFrom extends AnyObject, TTo extends AnyObject>(): <TFn extends <TInput extends TFrom>(cb: TInput) => { [K in keyof TInput]: TTo; }>(fn: TFn) => Mapper<TFrom, TTo>;
 
-declare function mergeObjects<D extends Narrowable, O extends Narrowable, TDefault extends NarrowObject<D>, TOverride extends NarrowObject<O>>(defVal: TDefault, override: TOverride): MergeObjects<TDefault, TOverride>;
+/**
+ * merge two objects while preserving narrow types
+ */
+declare function mergeObjects<TDefault extends NarrowObject<D>, TOverride extends NarrowObject<O>, D extends Narrowable, O extends Narrowable>(defVal: TDefault, override: TOverride): MergeObjects<TDefault, TOverride>;
 
 /**
  * **mergeScalars**(a,b)

package/modules/runtime/dist/index.js

@@ -5521,18 +5521,10 @@ function createMapper() {
 
 // src/type-conversion/mergeObjects.ts
 function mergeObjects(defVal, override) {
-  const intersectingKeys = sharedKeys(defVal, override);
-  const defUnique = withoutKeys(defVal, ...intersectingKeys);
-  const overrideUnique = withoutKeys(defVal, ...intersectingKeys);
-  const merged = {
-    ...intersectingKeys.reduce(
-      (acc, key) => typeof override[key] === "undefined" ? { ...acc, [key]: defVal[key] } : { ...acc, [key]: override[key] },
-      {}
-    ),
-    ...defUnique,
-    ...overrideUnique
+  return {
+    ...defVal,
+    ...override
   };
-  return merged;
 }
 
 // src/type-conversion/mergeScalars.ts