Custom merge that doesn't override values with undefined

[RebeccaStevens]

import {
  deepmergeCustom,
  type DeepMergeLeaf,
  type DeepMergeMergeFunctionsURIs,
} from "deepmerge-ts";

export const deepmergeDefined = deepmergeCustom<{
  DeepMergeOthersURI: "DeepMergeLeafNoUndefinedOverrideURI";
}>({
  mergeOthers: (values, utils) =>
    utils.defaultMergeFunctions.mergeOthers(
      values.filter((v) => v !== undefined)
    ),
});


declare module "deepmerge-ts" {
  interface DeepMergeMergeFunctionURItoKind<
    Ts extends ReadonlyArray<unknown>,
    MF extends DeepMergeMergeFunctionsURIs,
    in out M
  > {
    readonly DeepMergeLeafNoUndefinedOverrideURI: DeepMergeLeafNoUndefinedOverride<Ts>;
  }
}

type DeepMergeLeafNoUndefinedOverride<Ts extends ReadonlyArray<unknown>> =
  DeepMergeLeaf<FilterOutUnderfined<Ts>>;

type FilterOutUnderfined<T extends ReadonlyArray<unknown>> =
  FilterOutUnderfinedHelper<T, []>;

type FilterOutUnderfinedHelper<
  T extends ReadonlyArray<unknown>,
  Acc extends ReadonlyArray<unknown>
> = T extends readonly []
  ? Acc
  : T extends readonly [infer Head, ...infer Rest]
  ? Head extends undefined
    ? FilterOutUnderfinedHelper<Rest, Acc>
    : FilterOutUnderfinedHelper<Rest, [...Acc, Head]>
  : T;

import { deepmergeDefined} from "./path/to/file";

const alex = {
  name: {
    first: "Alex",
    last: "Alexson",
  },
  pets: ["Cat", "Parrot"],
};

const tony = {
  name: {
    first: undefined,
    last: "Tonison",
  },
  pets: ["Dog"],
};

const result = deepmergeDefined(alex, tony);
console.log(result);

// {
//   name: {
//     first: "Alex"
//     last: "Tonison"
//   }
//   pets: [
//     "Cat"
//     "Parrot"
//     "Dog"
//   ]
// }

[percy507]

export const myDeepmerge = deepmergeCustom<{
  DeepMergeOthersURI: "DeepMergeLeafNoUndefinedOverrideURI";
}>({
  mergeOthers: (values, utils) =>
    utils.defaultMergeFunctions.mergeOthers(
      values.filter((v) => v !== undefined),
      utils
    )
});

@RebeccaStevens The example seems have error.

[RebeccaStevens]

I've just updating the code above to now work with the latest version of the library. Try the new example.

[percy507]

Works fine. Thank u.

But I still have a problem. I add mergeArrays: false, option to the example and make a test. I find the merged type is not right and confused to how to fix it.

See below image, the type of a expected be string[].

[percy507]

Ah, find it. Thanks again.

[percy507]

Continue the above example with the additional option mergeArrays: false.

I create an usual example: merge default options and input options in a class constructor. But the merged type is unexpected. Then I have to use type assertion. I wonder how to fix this.

import { deepmerge } from './deepmerge';

interface Options {
  opt1?: string;
  opt2?: boolean;
  opt3?: boolean;
  opt4?: string[];
}

const defaultOptions = {
  opt3: true,
  opt4: [] as string[],
};

type MergedOptions = typeof defaultOptions & Options;

export class MyEditor {
  #options;
  #options2;

  constructor(options: Options) {
    this.#options = deepmerge(defaultOptions, options);

    // ==> Wrong: vscode recognizes `opt4` as `string[] | undefined`
    if (this.#options.opt4.length > 2) {
      // do something
    }

    this.#options2 = deepmerge(defaultOptions, options) as MergedOptions;

    // ==> Expected: vscode recognizes `opt4` as `string[]`
    if (this.#options2.opt4.length > 2) {
      // do something
    }
  }
}

[RebeccaStevens]

Looks like you have found a bug/limitation of types of this custom deepmerge. I'll need to spend some time investigating to come up with a fix. For now, you it's probably best to just use as MergedOptions as you are.

An alternative workaround would be to un-optional-ize the Options type with something like:

type Unoptionalize<T> = {
  [K in OptionalKeys<T>]-?: T[K] | undefined;
} & {
  [K in RequiredKeys<T>]: T[K];
};

type KeysOfType<T, U> = {
  [K in keyof T]: T[K] extends U ? K : never;
}[keyof T];

type RequiredKeys<T> = Exclude<
  KeysOfType<T, Exclude<T[keyof T], undefined>>,
  undefined
>;

type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;

this.#options = deepmerge(defaultOptions, options as Unoptionalize<Options>);

I'll probably need to somehow incorporate these types into the actual fix.