@xsai/stream-object 0.4.0-beta.9 → 0.4.0

package/dist/index.d.ts

@@ -1,5 +1,175 @@
 import { StreamTextOptions, StreamTextResult } from '@xsai/stream-text';
-import { Schema, Infer } from 'xsschema';
+import { Schema } from 'xsschema';
+
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+type Admin = {
+	name: string;
+	surname?: string;
+};
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> =
+	IsAny<Type | Key> extends true ? never
+		: Key extends keyof Type
+			? Type extends Record<Key, Type[Key]>
+				? false
+				: true
+			: false;
+
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice',
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD,
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<Type extends object> =
+	Type extends unknown // For distributing `Type`
+		? (keyof {[Key in keyof Type as
+			IsOptionalKeyOf<Type, Key> extends false
+				? never
+				: Key
+			]: never
+		}) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+		: never; // Should never happen
+
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
+
+type User = {
+	name: string;
+	surname: string;
+	luckyNumber?: number;
+};
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<Type extends object> =
+	Type extends unknown // For distributing `Type`
+		? Exclude<keyof Type, OptionalKeysOf<Type>>
+		: never; // Should never happen
 
 /**
 Returns a boolean for whether the given type is `never`.
@@ -14,29 +184,41 @@ Useful in type utilities, such as checking if something does not occur.
 ```
 import type {IsNever, And} from 'type-fest';
 
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
+type A = IsNever<never>;
+//=> true
 
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
+type B = IsNever<any>;
+//=> false
 
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
+type C = IsNever<unknown>;
+//=> false
 
-endIfEqual('abc', 'abc');
-//=> never
+type D = IsNever<never[]>;
+//=> false
 
-endIfEqual('abc', '123');
-//=> void
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//   ^? type A = never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//   ^? type B = false
 ```
 
 @category Type Guard
@@ -45,75 +227,125 @@ endIfEqual('abc', '123');
 type IsNever<T> = [T] extends [never] ? true : false;
 
 /**
-An if-else-like type that resolves depending on whether the given type is `never`.
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
 
-@see {@link IsNever}
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
 
 @example
 ```
-import type {IfNever} from 'type-fest';
+import type {If} from 'type-fest';
 
-type ShouldBeTrue = IfNever<never>;
-//=> true
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
 ```
 
-@category Type Guard
-@category Utilities
-*/
-type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
-	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
-);
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
 
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
 
-/**
-Returns a boolean for whether the given type is `any`.
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
 
-@link https://stackoverflow.com/a/49928360/1490091
+@example
+```
+import type {If, IsEqual} from 'type-fest';
 
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
 
 @example
 ```
-import type {IsAny} from 'type-fest';
+import type {If, IsEqual, StringRepeat} from 'type-fest';
 
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
+type HundredZeroes = StringRepeat<'0', 100>;
 
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
 
-const typedA = get(typedObject, 'a');
-//=> 1
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
 
-const anyA = get(anyObject, 'a');
-//=> any
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
 ```
 
 @category Type Guard
 @category Utilities
 */
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+type If<Type extends boolean, IfBranch, ElseBranch> =
+	IsNever<Type> extends true
+		? ElseBranch
+		: Type extends true
+			? IfBranch
+			: ElseBranch;
 
 /**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
 
-@category Type
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
 */
-type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
+	T extends {(...arguments_: infer A): unknown; (...arguments_: infer B): unknown}
+		? B extends A
+			? A extends B
+				? false
+				: true
+			: true
+		: false;
 
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
@@ -160,89 +392,21 @@ const literal = {foo: 123, bar: 'hello', baz: 456};
 const someType: SomeType = literal;
 const someInterface: SomeInterface = literal;
 
-function fn(object: Record<string, unknown>): void {}
+declare function fn(object: Record<string, unknown>): void;
 
 fn(literal); // Good: literal object type is sealed
 fn(someType); // Good: type is sealed
+// @ts-expect-error
 fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
 fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
 ```
 
 @link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
+@see {@link SimplifyDeep}
 @category Object
 */
 type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
 
-/**
-Extract all optional keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-interface User {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
-};
-
-const update1: UpdateOperation<User> = {
-	name: 'Alice'
-};
-
-const update2: UpdateOperation<User> = {
-	name: 'Bob',
-	luckyNumber: REMOVE_FIELD
-};
-```
-
-@category Utilities
-*/
-type OptionalKeysOf<BaseType extends object> =
-	BaseType extends unknown // For distributing `BaseType`
-		? (keyof {
-			[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never
-		}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
-		: never; // Should never happen
-
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
-
-interface User {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-```
-
-@category Utilities
-*/
-type RequiredKeysOf<BaseType extends object> =
-	BaseType extends unknown // For distributing `BaseType`
-		? Exclude<keyof BaseType, OptionalKeysOf<BaseType>>
-		: never; // Should never happen
-
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -260,6 +424,7 @@ It relies on the fact that an empty object (`{}`) is assignable to an object wit
 ```
 const indexed: Record<string, unknown> = {}; // Allowed
 
+// @ts-expect-error
 const keyed: Record<'foo', unknown> = {}; // Error
 // => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
 ```
@@ -273,16 +438,14 @@ type Indexed = {} extends Record<string, unknown>
 // => '✅ `{}` is assignable to `Record<string, unknown>`'
 
 type Keyed = {} extends Record<'foo' | 'bar', unknown>
-	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
-	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
 // => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
 ```
 
 Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
 
 ```
-import type {OmitIndexSignature} from 'type-fest';
-
 type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
 	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
@@ -292,14 +455,12 @@ type OmitIndexSignature<ObjectType> = {
 ...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
 
 ```
-import type {OmitIndexSignature} from 'type-fest';
-
 type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType
-		// Is `{}` assignable to `Record<KeyType, unknown>`?
-		as {} extends Record<KeyType, unknown>
-			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
 	]: ObjectType[KeyType];
 };
 ```
@@ -310,27 +471,27 @@ If `{}` is assignable, it means that `KeyType` is an index signature and we want
 ```
 import type {OmitIndexSignature} from 'type-fest';
 
-interface Example {
+type Example = {
 	// These index signatures will be removed.
-	[x: string]: any
-	[x: number]: any
-	[x: symbol]: any
-	[x: `head-${string}`]: string
-	[x: `${string}-tail`]: string
-	[x: `head-${string}-tail`]: string
-	[x: `${bigint}`]: string
-	[x: `embedded-${number}`]: string
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
 
 	// These explicitly defined keys will remain.
 	foo: 'bar';
 	qux?: 'baz';
-}
+};
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 // => { foo: 'bar'; qux?: 'baz' | undefined; }
 ```
 
-@see PickIndexSignature
+@see {@link PickIndexSignature}
 @category Object
 */
 type OmitIndexSignature<ObjectType> = {
@@ -381,7 +542,7 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 // }
 ```
 
-@see OmitIndexSignature
+@see {@link OmitIndexSignature}
 @category Object
 */
 type PickIndexSignature<ObjectType> = {
@@ -402,12 +563,12 @@ Merge two types into a new type. Keys of the second type overrides keys of the f
 ```
 import type {Merge} from 'type-fest';
 
-interface Foo {
+type Foo = {
 	[x: string]: unknown;
 	[x: number]: unknown;
 	foo: string;
 	bar: symbol;
-}
+};
 
 type Bar = {
 	[x: number]: number;
@@ -431,38 +592,10 @@ export type FooBar = Merge<Foo, Bar>;
 */
 type Merge<Destination, Source> =
 Simplify<
-SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
-& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
+	SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
+	& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
 >;
 
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
-	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
-);
-
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-
 /**
 Merges user specified options with default options.
 
@@ -520,18 +653,13 @@ type ApplyDefaultOptions<
 	Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>,
 	SpecifiedOptions extends Options,
 > =
-	IfAny<SpecifiedOptions, Defaults,
-	IfNever<SpecifiedOptions, Defaults,
-	Simplify<Merge<Defaults, {
-		[Key in keyof SpecifiedOptions
-		as Key extends OptionalKeysOf<Options>
-			? Extract<SpecifiedOptions[Key], undefined> extends never
-				? Key
-				: never
-			: Key
-		]: SpecifiedOptions[Key]
-	}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-	>>;
+	If<IsAny<SpecifiedOptions>, Defaults,
+		If<IsNever<SpecifiedOptions>, Defaults,
+			Simplify<Merge<Defaults, {
+				[Key in keyof SpecifiedOptions
+				as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key
+				]: SpecifiedOptions[Key]
+			}> & Required<Options>>>>;
 
 /**
 @see {@link PartialDeep}
@@ -550,10 +678,10 @@ type PartialDeepOptions = {
 	- When set to `true`, elements of non-tuple arrays can be `undefined`.
 	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
 
-	@default true
+	@default false
 
 	@example
-	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+	You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
 
 	```
 	import type {PartialDeep} from 'type-fest';
@@ -562,10 +690,9 @@ type PartialDeepOptions = {
 		languages: string[];
 	};
 
-	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
 
-	partialSettings.languages = [undefined]; // Error
-	partialSettings.languages = []; // Ok
+	partialSettings.languages = [undefined]; // OK
 	```
 	*/
 	readonly allowUndefinedInNonTupleArrays?: boolean;
@@ -573,7 +700,7 @@ type PartialDeepOptions = {
 
 type DefaultPartialDeepOptions = {
 	recurseIntoArrays: false;
-	allowUndefinedInNonTupleArrays: true;
+	allowUndefinedInNonTupleArrays: false;
 };
 
 /**
@@ -587,19 +714,19 @@ Use-cases:
 ```
 import type {PartialDeep} from 'type-fest';
 
-const settings: Settings = {
+let settings = {
 	textEditor: {
 		fontSize: 14,
 		fontColor: '#000000',
-		fontWeight: 400
+		fontWeight: 400,
 	},
 	autocomplete: false,
-	autosave: true
+	autosave: true,
 };
 
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
 
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
@@ -609,13 +736,15 @@ By default, this does not affect elements in array and tuple types. You can chan
 ```
 import type {PartialDeep} from 'type-fest';
 
-type Settings = {
-	languages: string[];
-}
+type Shape = {
+	dimensions: [number, number];
+};
 
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
 };
+
+partialShape.dimensions = [15]; // OK
 ```
 
 @see {@link PartialDeepOptions}
@@ -630,16 +759,20 @@ type PartialDeep<T, Options extends PartialDeepOptions = {}> =
 
 type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown))
 	? T
-	: IsNever<keyof T> extends true // For functions with no properties
-		? T
-		: T extends Map<infer KeyType, infer ValueType>
-			? PartialMapDeep<KeyType, ValueType, Options>
-			: T extends Set<infer ItemType>
-				? PartialSetDeep<ItemType, Options>
-				: T extends ReadonlyMap<infer KeyType, infer ValueType>
-					? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-					: T extends ReadonlySet<infer ItemType>
-						? PartialReadonlySetDeep<ItemType, Options>
+	: T extends Map<infer KeyType, infer ValueType>
+		? PartialMapDeep<KeyType, ValueType, Options>
+		: T extends Set<infer ItemType>
+			? PartialSetDeep<ItemType, Options>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
+				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+				: T extends ReadonlySet<infer ItemType>
+					? PartialReadonlySetDeep<ItemType, Options>
+					: T extends (...arguments_: any[]) => unknown
+						? IsNever<keyof T> extends true
+							? T // For functions with no properties
+							: HasMultipleCallSignatures<T> extends true
+								? T
+								: ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options>
 						: T extends object
 							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 								? Options['recurseIntoArrays'] extends true
@@ -675,15 +808,12 @@ type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> =
-	(ObjectType extends (...arguments_: any) => unknown
-		? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType>
-		: {}) & ({
-		[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
-	});
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
+	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
+};
 
 interface StreamObjectOnFinishResult<T extends Schema> {
-    object?: Infer<T>;
+    object?: Schema.InferOutput<T>;
 }
 interface StreamObjectOptions<T extends Schema> extends StreamTextOptions {
     schema: T;
@@ -693,24 +823,24 @@ interface StreamObjectOptions<T extends Schema> extends StreamTextOptions {
     strict?: boolean;
 }
 interface StreamObjectResult<T extends Schema> extends StreamTextResult {
-    elementStream?: ReadableStream<Infer<T>>;
-    partialObjectStream?: ReadableStream<PartialDeep<Infer<T>>>;
+    elementStream?: ReadableStream<Schema.InferOutput<T>>;
+    partialObjectStream?: ReadableStream<PartialDeep<Schema.InferOutput<T>>>;
 }
 declare function streamObject<T extends Schema>(options: StreamObjectOptions<T> & {
     output: 'array';
 }): Promise<StreamObjectResult<T> & {
-    elementStream: ReadableStream<Infer<T>>;
+    elementStream: ReadableStream<Schema.InferOutput<T>>;
     partialObjectStream: undefined;
 }>;
 declare function streamObject<T extends Schema>(options: StreamObjectOptions<T> & {
     output: 'object';
 }): Promise<StreamObjectResult<T> & {
     elementStream: undefined;
-    partialObjectStream: ReadableStream<PartialDeep<Infer<T>>>;
+    partialObjectStream: ReadableStream<PartialDeep<Schema.InferOutput<T>>>;
 }>;
 declare function streamObject<T extends Schema>(options: StreamObjectOptions<T>): Promise<StreamObjectResult<T> & {
     elementStream: undefined;
-    partialObjectStream: ReadableStream<PartialDeep<Infer<T>>>;
+    partialObjectStream: ReadableStream<PartialDeep<Schema.InferOutput<T>>>;
 }>;
 
 declare const toElementStream: <T>(stream: ReadableStream<string>) => ReadableStream<T>;

package/dist/index.js

@@ -19,23 +19,23 @@ var hasRequiredParse;
 function requireParse () {
 	if (hasRequiredParse) return parse;
 	hasRequiredParse = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.parse = exports.enableErrorLogging = exports.disableErrorLogging = exports.setErrorLogger = void 0;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.parse = exports$1.enableErrorLogging = exports$1.disableErrorLogging = exports$1.setErrorLogger = void 0;
 		let logError = console.error;
 		function setErrorLogger(logger) {
 		  logError = logger;
 		}
-		exports.setErrorLogger = setErrorLogger;
+		exports$1.setErrorLogger = setErrorLogger;
 		function disableErrorLogging() {
 		  logError = () => {
 		  };
 		}
-		exports.disableErrorLogging = disableErrorLogging;
+		exports$1.disableErrorLogging = disableErrorLogging;
 		function enableErrorLogging() {
 		  logError = console.error;
 		}
-		exports.enableErrorLogging = enableErrorLogging;
+		exports$1.enableErrorLogging = enableErrorLogging;
 		function parse(s) {
 		  if (s === void 0) {
 		    return void 0;
@@ -62,7 +62,7 @@ function requireParse () {
 		    return data;
 		  }
 		}
-		exports.parse = parse;
+		exports$1.parse = parse;
 		(function(parse2) {
 		  parse2.onExtraToken = (text, data, reminding) => {
 		    logError("parsed json with extra tokens:", {
@@ -71,7 +71,7 @@ function requireParse () {
 		      reminding
 		    });
 		  };
-		})(parse = exports.parse || (exports.parse = {}));
+		})(parse = exports$1.parse || (exports$1.parse = {}));
 		function parseAny(s, e, fallback) {
 		  const parser = parsers[s[0]] || fallback;
 		  if (!parser) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/stream-object",
   "type": "module",
-  "version": "0.4.0-beta.9",
+  "version": "0.4.0",
   "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -29,13 +29,13 @@
     "dist"
   ],
   "dependencies": {
-    "@xsai/stream-text": "~0.4.0-beta.9",
-    "xsschema": "~0.4.0-beta.9"
+    "@xsai/stream-text": "~0.4.0",
+    "xsschema": "~0.4.0"
   },
   "devDependencies": {
     "@valibot/to-json-schema": "^1.0.0",
-    "best-effort-json-parser": "^1.1.3",
-    "type-fest": "^4.41.0",
+    "best-effort-json-parser": "^1.2.1",
+    "type-fest": "^5.3.1",
     "valibot": "^1.0.0"
   },
   "scripts": {