feat: create defuSchema

Fixes unjs#48

src/defu.ts

@@ -1,4 +1,9 @@
-import type { Merger, DefuFn as DefuFunction, DefuInstance } from "./types";
+import type {
+  Merger,
+  DefuFn as DefuFunction,
+  DefuInstance,
+  DefuFnSchema,
+} from "./types";
 
 function isObject(value: any) {
   return value !== null && typeof value === "object";
@@ -79,4 +84,16 @@ export const defuArrayFn = createDefu((object, key, currentValue) => {
   }
 });
 
+// Custom version for skipping keys not present in defaults
+export const defuSchema = createDefu((schema, key) => {
+  // Checking for hasOwnProperty is required for compatibility with older browsers
+  if (
+    !Object.hasOwn?.(schema, key) ||
+    !Object.prototype.hasOwnProperty.call(schema, key)
+  ) {
+    return true;
+  }
+  return false;
+}) as DefuFnSchema;
+
 export type { Defu } from "./types";

src/types.ts

@@ -56,6 +56,24 @@ export type DefuFn = <
   ...defaults: Defaults
 ) => Defu<Source, Defaults>;
 
+export type DefuFnSchema = <
+  Source extends Input,
+  Defaults extends Array<Input | IgnoredInput>
+>(
+  source: Source,
+  ...defaults: Defaults
+) => Defaults extends [infer F, ...infer Rest]
+  ? F extends Input
+    ? Rest extends Array<Input | IgnoredInput>
+      ? Defu<MergeObjects<F, F>, Rest>
+      : MergeObjects<F, F>
+    : F extends IgnoredInput
+    ? Rest extends Array<Input | IgnoredInput>
+      ? Defu<F, Rest>
+      : F
+    : F
+  : never;
+
 export interface DefuInstance {
   <Source extends Input, Defaults extends Array<Input | IgnoredInput>>(
     source: Source | IgnoredInput,

test/defu.test.ts

@@ -1,6 +1,6 @@
 import { expectTypeOf } from "expect-type";
 import { it, describe, expect } from "vitest";
-import { defu, createDefu, defuFn, defuArrayFn } from "../src/defu";
+import { defu, createDefu, defuFn, defuArrayFn, defuSchema } from "../src/defu";
 
 // Part of tests brought from jonschlinkert/defaults-deep (MIT)
 const nonObject = [null, undefined, [], false, true, 123];
@@ -22,6 +22,25 @@ describe("defu", () => {
     expectTypeOf(result2).toEqualTypeOf<{ a: string; d: string }>();
   });
 
+  it("defuSchema(): should skip keys non present in default object", () => {
+    const result = defuSchema(
+      { a: 1, b: 2, c: 3, d: 4 },
+      { a: 2, c: 4, d: 6, e: 8 }
+    );
+    expect(result).toEqual({
+      a: 1,
+      c: 3,
+      d: 4,
+      e: 8,
+    });
+    expectTypeOf(result).toEqualTypeOf<{
+      a: number;
+      c: number;
+      d: number;
+      e: number;
+    }>();
+  });
+
   it("should copy nested values", () => {
     const result = defu({ a: { b: "c" } }, { a: { d: "e" } });
     expect(result).toEqual({