Enhance Except type

readme.md

@@ -902,4 +902,4 @@ You can find some examples in the [TypeScript docs](https://www.typescriptlang.o
 
 ## License
 
-SPDX-License-Identifier: (MIT OR CC0-1.0)
+SPDX-License-Identifier: (MIT OR CC0-1.0)

source/except.d.ts

@@ -25,9 +25,18 @@ type Filtered = Filter<'bar', 'foo'>;
 //=> 'bar'
 ```
 
-@see {Except}
+@see {NonStrictExcept}
 */
-type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type Filter<KeyType, ExcludeType> =
+IsEqual<KeyType, ExcludeType> extends true ? never :
+ KeyType extends ExcludeType ? never : KeyType;
+
+type ExceptOptions = {
+ /**
+ @default false
+ */
+ strict?: boolean;
+};
 
 /**
 Create a type from an object type without certain keys.
@@ -36,22 +45,71 @@ This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/
 
 This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
 
+The NonStrictExcept refers to the standard Except method that permits the assignment of an object with additional properties to an object of a different type.
+@see https://github.com/sindresorhus/type-fest/issues/556
+
+@category Object
+*/
+type NonStrictExcept<ObjectType, KeysType extends keyof ObjectType> = {
+ [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+};
+
+/**
+Create a type from an object type without certain keys - in stricter way.
+When the "strict" option in ExceptOptions is true, StrictExcept will be used.
+
+The StrictExcept method resolves the problem that arises when an object with additional properties is assigned to an object of a different type.
+@see https://github.com/sindresorhus/type-fest/issues/556
+
+@category Object
+*/
+
+type StrictExcept<ObjectType, KeysType extends keyof ObjectType> = NonStrictExcept<ObjectType, KeysType> & Partial<Record<KeysType, never>>;
+
+/**
+The Except type is the exported type, which determines the appropriate method to use (NonStrictExcept or StrictExcept) based on the options provided as the third argument (which is set to false by default).
+
 @example
 ```
-import type {Except} from 'type-fest';
+import {Except} from 'type-fest';
 
 type Foo = {
  a: number;
  b: string;
  c: boolean;
 };
 
-type FooWithoutA = Except<Foo, 'a' | 'c'>;
-//=> {b: string};
+type FooWithoutA = Except<Foo, 'a', {strict: false}>; // False by default
+
+const foo: Foo = {
+ a: 1,
+ b: 'b',
+ c: true,
+};
+
+const fooWithoutA: FooWithoutA = foo; // No error
+//=> NonStrictExcept<Foo, 'a'>;
+
+@example
 ```
+import {Except} from 'type-fest';
 
-@category Object
-*/
-export type Except<ObjectType, KeysType extends keyof ObjectType> = {
- [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+type Foo = {
+ a: number;
+ b: string;
+ c: boolean;
+};
+
+type FooWithoutA = Except<Foo, 'a', {strict: true}>;
+
+const foo: Foo = {
+ a: 1,
+ b: 'b',
+ c: true,
 };
+
+const fooWithoutA: FooWithoutA = foo; // Error
+//=> StrictExcept<Foo, 'a'>;
+*/
+export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {strict: false}> =
+Options['strict'] extends false ? NonStrictExcept<ObjectType, KeysType> : StrictExcept<ObjectType, KeysType>;

test-d/except.ts

@@ -11,7 +11,7 @@ type Example = {
  bar: string;
 };
 
-const test: Except<Example, 'bar'> = {foo: 123, bar: 'asdf'};
+const test: Except<Example, 'bar', {strict: false}> = {foo: 123, bar: 'asdf'};
 expectType<number>(test.foo);
 // eslint-disable-next-line @typescript-eslint/dot-notation
 expectType<unknown>(test['bar']);