@xsai/stream-object 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/index.d.ts

@@ -1,7 +1,789 @@
 import { StreamTextOptions, StreamTextResult } from '@xsai/stream-text';
-import { PartialDeep } from 'type-fest';
 import { Schema, Infer } 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;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void)
+	// The `& Union` is to allow indexing by the resulting type
+	? Intersection & Union
+	: never;
+
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+type KeysOfUnion<ObjectType> =
+  // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+  keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+
+/**
+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> = KeysOfUnion<{
+	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never
+}>;
+
+/**
+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
+
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+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 EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
+// 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;
+
+/**
+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>(obj: O, key: K) {
+	return obj[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;
+
+/**
+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.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+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
+@category Object
+*/
+type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `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 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`.
+};
+```
+
+...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>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+interface 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
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};
+
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[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 be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see OmitIndexSignature
+@category Object
+*/
+type PickIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? KeyType
+		: never]: ObjectType[KeyType];
+};
+
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = {
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+interface Foo {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+}
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+@category Object
+*/
+type Merge<Destination, Source> =
+Simplify<
+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.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<
+	Options extends object,
+	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>`
+	>>;
+
+/**
+@see {@link PartialDeep}
+*/
+type PartialDeepOptions = {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+	readonly recurseIntoArrays?: boolean;
+
+	/**
+	Allows `undefined` values in non-tuple arrays.
+
+	- 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
+
+	@example
+	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+
+	```
+	import type {PartialDeep} from 'type-fest';
+
+	type Settings = {
+		languages: string[];
+	};
+
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
+
+	partialSettings.languages = [undefined]; // Error
+	partialSettings.languages = []; // Ok
+	```
+	*/
+	readonly allowUndefinedInNonTupleArrays?: boolean;
+};
+
+type DefaultPartialDeepOptions = {
+	recurseIntoArrays: false;
+	allowUndefinedInNonTupleArrays: true;
+};
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400
+	},
+	autocomplete: false,
+	autosave: true
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Settings = {
+	languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
+	languages: [undefined]
+};
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> =
+	_PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
+	? 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 object
+						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+							? Options['recurseIntoArrays'] extends true
+								? ItemType[] extends T // Test for arrays (non-tuples) specifically
+									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+										? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
+										: Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>>
+									: PartialObjectDeep<T, Options> // Tuples behave properly
+								: T // If they don't opt into array testing, just use the original type
+							: PartialObjectDeep<T, Options>
+						: unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+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>;
 }

package/dist/index.js

@@ -1,257 +1,237 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import { streamText } from '@xsai/stream-text';
+import { toJsonSchema } from 'xsschema';
 
-// ../../node_modules/.pnpm/best-effort-json-parser@1.1.3/node_modules/best-effort-json-parser/dist/parse.js
-var require_parse = __commonJS({
-  "../../node_modules/.pnpm/best-effort-json-parser@1.1.3/node_modules/best-effort-json-parser/dist/parse.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.parse = void 0;
-    function parse2(s) {
-      if (s === void 0) {
-        return void 0;
-      }
-      if (s === null) {
-        return null;
-      }
-      if (s === "") {
-        return "";
-      }
-      s = s.replace(/\\+$/, (match) => match.length % 2 === 0 ? match : match.slice(0, -1));
-      try {
-        return JSON.parse(s);
-      } catch (e) {
-        const [data, reminding] = s.trimLeft()[0] === ":" ? parseAny(s, e) : parseAny(s, e, parseStringWithoutQuote);
-        parse2.lastParseReminding = reminding;
-        if (parse2.onExtraToken && reminding.length > 0) {
-          const trimmedReminding = reminding.trimRight();
-          parse2.lastParseReminding = trimmedReminding;
-          if (trimmedReminding.length > 0) {
-            parse2.onExtraToken(s, data, trimmedReminding);
-          }
-        }
-        return data;
-      }
-    }
-    exports.parse = parse2;
-    (function(parse3) {
-      parse3.onExtraToken = (text, data, reminding) => {
-        console.error("parsed json with extra tokens:", {
-          text,
-          data,
-          reminding
-        });
-      };
-    })(parse2 = exports.parse || (exports.parse = {}));
-    function parseAny(s, e, fallback) {
-      const parser = parsers[s[0]] || fallback;
-      if (!parser) {
-        console.error(`no parser registered for ${JSON.stringify(s[0])}:`, { s });
-        throw e;
-      }
-      return parser(s, e);
-    }
-    function parseStringCasual(s, e, delimiters) {
-      if (s[0] === '"') {
-        return parseString(s);
-      }
-      if (s[0] === "'") {
-        return parseSingleQuoteString(s);
-      }
-      return parseStringWithoutQuote(s, e, delimiters);
-    }
-    var parsers = {};
-    function skipSpace(s) {
-      return s.trimLeft();
-    }
-    parsers[" "] = parseSpace;
-    parsers["\r"] = parseSpace;
-    parsers["\n"] = parseSpace;
-    parsers["	"] = parseSpace;
-    function parseSpace(s, e) {
-      s = skipSpace(s);
-      return parseAny(s, e);
-    }
-    parsers["["] = parseArray;
-    function parseArray(s, e) {
-      s = s.substr(1);
-      const acc = [];
-      s = skipSpace(s);
-      for (; s.length > 0; ) {
-        if (s[0] === "]") {
-          s = s.substr(1);
-          break;
-        }
-        const res = parseAny(s, e, (s2, e2) => parseStringWithoutQuote(s2, e2, [",", "]"]));
-        acc.push(res[0]);
-        s = res[1];
-        s = skipSpace(s);
-        if (s[0] === ",") {
-          s = s.substring(1);
-          s = skipSpace(s);
-        }
-      }
-      return [acc, s];
-    }
-    for (const c of "0123456789.-".slice()) {
-      parsers[c] = parseNumber;
-    }
-    function parseNumber(s) {
-      for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (parsers[c] === parseNumber) {
-          continue;
-        }
-        const num = s.substring(0, i);
-        s = s.substring(i);
-        return [numToStr(num), s];
-      }
-      return [numToStr(s), ""];
-    }
-    function numToStr(s) {
-      if (s === "-") {
-        return -0;
-      }
-      const num = +s;
-      if (Number.isNaN(num)) {
-        return s;
-      }
-      return num;
-    }
-    parsers['"'] = parseString;
-    function parseString(s) {
-      for (let i = 1; i < s.length; i++) {
-        const c = s[i];
-        if (c === "\\") {
-          i++;
-          continue;
-        }
-        if (c === '"') {
-          const str = fixEscapedCharacters(s.substring(0, i + 1));
-          s = s.substring(i + 1);
-          return [JSON.parse(str), s];
-        }
-      }
-      return [JSON.parse(fixEscapedCharacters(s) + '"'), ""];
-    }
-    function fixEscapedCharacters(s) {
-      return s.replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
-    }
-    parsers["'"] = parseSingleQuoteString;
-    function parseSingleQuoteString(s) {
-      for (let i = 1; i < s.length; i++) {
-        const c = s[i];
-        if (c === "\\") {
-          i++;
-          continue;
-        }
-        if (c === "'") {
-          const str = fixEscapedCharacters(s.substring(0, i + 1));
-          s = s.substring(i + 1);
-          return [JSON.parse('"' + str.slice(1, -1) + '"'), s];
-        }
-      }
-      return [JSON.parse('"' + fixEscapedCharacters(s.slice(1)) + '"'), ""];
-    }
-    function parseStringWithoutQuote(s, e, delimiters = [" "]) {
-      const index = Math.min(...delimiters.map((delimiter) => {
-        const index2 = s.indexOf(delimiter);
-        return index2 === -1 ? s.length : index2;
-      }));
-      const value = s.substring(0, index).trim();
-      const rest = s.substring(index);
-      return [value, rest];
-    }
-    parsers["{"] = parseObject;
-    function parseObject(s, e) {
-      s = s.substr(1);
-      const acc = {};
-      s = skipSpace(s);
-      for (; s.length > 0; ) {
-        if (s[0] === "}") {
-          s = s.substr(1);
-          break;
-        }
-        const keyRes = parseStringCasual(s, e, [":", "}"]);
-        const key = keyRes[0];
-        s = keyRes[1];
-        s = skipSpace(s);
-        if (s[0] !== ":") {
-          acc[key] = void 0;
-          break;
-        }
-        s = s.substr(1);
-        s = skipSpace(s);
-        if (s.length === 0) {
-          acc[key] = void 0;
-          break;
-        }
-        const valueRes = parseAny(s, e);
-        acc[key] = valueRes[0];
-        s = valueRes[1];
-        s = skipSpace(s);
-        if (s[0] === ",") {
-          s = s.substr(1);
-          s = skipSpace(s);
-        }
-      }
-      return [acc, s];
-    }
-    parsers["t"] = parseTrue;
-    function parseTrue(s, e) {
-      return parseToken(s, `true`, true, e);
-    }
-    parsers["f"] = parseFalse;
-    function parseFalse(s, e) {
-      return parseToken(s, `false`, false, e);
-    }
-    parsers["n"] = parseNull;
-    function parseNull(s, e) {
-      return parseToken(s, `null`, null, e);
-    }
-    function parseToken(s, tokenStr, tokenVal, e) {
-      for (let i = tokenStr.length; i >= 1; i--) {
-        if (s.startsWith(tokenStr.slice(0, i))) {
-          return [tokenVal, s.slice(i)];
-        }
-      }
-      {
-        const prefix = JSON.stringify(s.slice(0, tokenStr.length));
-        console.error(`unknown token starting with ${prefix}:`, { s });
-        throw e;
-      }
-    }
-  }
-});
+var parse = {};
+
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse;
+	hasRequiredParse = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.parse = void 0;
+		function parse(s) {
+		  if (s === void 0) {
+		    return void 0;
+		  }
+		  if (s === null) {
+		    return null;
+		  }
+		  if (s === "") {
+		    return "";
+		  }
+		  s = s.replace(/\\+$/, (match) => match.length % 2 === 0 ? match : match.slice(0, -1));
+		  try {
+		    return JSON.parse(s);
+		  } catch (e) {
+		    const [data, reminding] = s.trimLeft()[0] === ":" ? parseAny(s, e) : parseAny(s, e, parseStringWithoutQuote);
+		    parse.lastParseReminding = reminding;
+		    if (parse.onExtraToken && reminding.length > 0) {
+		      const trimmedReminding = reminding.trimRight();
+		      parse.lastParseReminding = trimmedReminding;
+		      if (trimmedReminding.length > 0) {
+		        parse.onExtraToken(s, data, trimmedReminding);
+		      }
+		    }
+		    return data;
+		  }
+		}
+		exports.parse = parse;
+		(function(parse2) {
+		  parse2.onExtraToken = (text, data, reminding) => {
+		    console.error("parsed json with extra tokens:", {
+		      text,
+		      data,
+		      reminding
+		    });
+		  };
+		})(parse = exports.parse || (exports.parse = {}));
+		function parseAny(s, e, fallback) {
+		  const parser = parsers[s[0]] || fallback;
+		  if (!parser) {
+		    console.error(`no parser registered for ${JSON.stringify(s[0])}:`, { s });
+		    throw e;
+		  }
+		  return parser(s, e);
+		}
+		function parseStringCasual(s, e, delimiters) {
+		  if (s[0] === '"') {
+		    return parseString(s);
+		  }
+		  if (s[0] === "'") {
+		    return parseSingleQuoteString(s);
+		  }
+		  return parseStringWithoutQuote(s, e, delimiters);
+		}
+		const parsers = {};
+		function skipSpace(s) {
+		  return s.trimLeft();
+		}
+		parsers[" "] = parseSpace;
+		parsers["\r"] = parseSpace;
+		parsers["\n"] = parseSpace;
+		parsers["	"] = parseSpace;
+		function parseSpace(s, e) {
+		  s = skipSpace(s);
+		  return parseAny(s, e);
+		}
+		parsers["["] = parseArray;
+		function parseArray(s, e) {
+		  s = s.substr(1);
+		  const acc = [];
+		  s = skipSpace(s);
+		  for (; s.length > 0; ) {
+		    if (s[0] === "]") {
+		      s = s.substr(1);
+		      break;
+		    }
+		    const res = parseAny(s, e, (s2, e2) => parseStringWithoutQuote(s2, e2, [",", "]"]));
+		    acc.push(res[0]);
+		    s = res[1];
+		    s = skipSpace(s);
+		    if (s[0] === ",") {
+		      s = s.substring(1);
+		      s = skipSpace(s);
+		    }
+		  }
+		  return [acc, s];
+		}
+		for (const c of "0123456789.-".slice()) {
+		  parsers[c] = parseNumber;
+		}
+		function parseNumber(s) {
+		  for (let i = 0; i < s.length; i++) {
+		    const c = s[i];
+		    if (parsers[c] === parseNumber) {
+		      continue;
+		    }
+		    const num = s.substring(0, i);
+		    s = s.substring(i);
+		    return [numToStr(num), s];
+		  }
+		  return [numToStr(s), ""];
+		}
+		function numToStr(s) {
+		  if (s === "-") {
+		    return -0;
+		  }
+		  const num = +s;
+		  if (Number.isNaN(num)) {
+		    return s;
+		  }
+		  return num;
+		}
+		parsers['"'] = parseString;
+		function parseString(s) {
+		  for (let i = 1; i < s.length; i++) {
+		    const c = s[i];
+		    if (c === "\\") {
+		      i++;
+		      continue;
+		    }
+		    if (c === '"') {
+		      const str = fixEscapedCharacters(s.substring(0, i + 1));
+		      s = s.substring(i + 1);
+		      return [JSON.parse(str), s];
+		    }
+		  }
+		  return [JSON.parse(fixEscapedCharacters(s) + '"'), ""];
+		}
+		function fixEscapedCharacters(s) {
+		  return s.replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
+		}
+		parsers["'"] = parseSingleQuoteString;
+		function parseSingleQuoteString(s) {
+		  for (let i = 1; i < s.length; i++) {
+		    const c = s[i];
+		    if (c === "\\") {
+		      i++;
+		      continue;
+		    }
+		    if (c === "'") {
+		      const str = fixEscapedCharacters(s.substring(0, i + 1));
+		      s = s.substring(i + 1);
+		      return [JSON.parse('"' + str.slice(1, -1) + '"'), s];
+		    }
+		  }
+		  return [JSON.parse('"' + fixEscapedCharacters(s.slice(1)) + '"'), ""];
+		}
+		function parseStringWithoutQuote(s, e, delimiters = [" "]) {
+		  const index = Math.min(...delimiters.map((delimiter) => {
+		    const index2 = s.indexOf(delimiter);
+		    return index2 === -1 ? s.length : index2;
+		  }));
+		  const value = s.substring(0, index).trim();
+		  const rest = s.substring(index);
+		  return [value, rest];
+		}
+		parsers["{"] = parseObject;
+		function parseObject(s, e) {
+		  s = s.substr(1);
+		  const acc = {};
+		  s = skipSpace(s);
+		  for (; s.length > 0; ) {
+		    if (s[0] === "}") {
+		      s = s.substr(1);
+		      break;
+		    }
+		    const keyRes = parseStringCasual(s, e, [":", "}"]);
+		    const key = keyRes[0];
+		    s = keyRes[1];
+		    s = skipSpace(s);
+		    if (s[0] !== ":") {
+		      acc[key] = void 0;
+		      break;
+		    }
+		    s = s.substr(1);
+		    s = skipSpace(s);
+		    if (s.length === 0) {
+		      acc[key] = void 0;
+		      break;
+		    }
+		    const valueRes = parseAny(s, e);
+		    acc[key] = valueRes[0];
+		    s = valueRes[1];
+		    s = skipSpace(s);
+		    if (s[0] === ",") {
+		      s = s.substr(1);
+		      s = skipSpace(s);
+		    }
+		  }
+		  return [acc, s];
+		}
+		parsers["t"] = parseTrue;
+		function parseTrue(s, e) {
+		  return parseToken(s, `true`, true, e);
+		}
+		parsers["f"] = parseFalse;
+		function parseFalse(s, e) {
+		  return parseToken(s, `false`, false, e);
+		}
+		parsers["n"] = parseNull;
+		function parseNull(s, e) {
+		  return parseToken(s, `null`, null, e);
+		}
+		function parseToken(s, tokenStr, tokenVal, e) {
+		  for (let i = tokenStr.length; i >= 1; i--) {
+		    if (s.startsWith(tokenStr.slice(0, i))) {
+		      return [tokenVal, s.slice(i)];
+		    }
+		  }
+		  {
+		    const prefix = JSON.stringify(s.slice(0, tokenStr.length));
+		    console.error(`unknown token starting with ${prefix}:`, { s });
+		    throw e;
+		  }
+		} 
+	} (parse));
+	return parse;
+}
 
-// src/index.ts
-var import_best_effort_json_parser = __toESM(require_parse(), 1);
-import { streamText } from "@xsai/stream-text";
-import { toJsonSchema } from "xsschema";
-var wrap = (schema) => {
+var parseExports = requireParse();
+
+const wrap = (schema) => {
   return {
     properties: {
       elements: {
@@ -292,14 +272,14 @@ async function streamObject(options) {
       let partialData = "";
       elementStream = rawElementStream.pipeThrough(new TransformStream({
         flush: (controller) => {
-          const data = (0, import_best_effort_json_parser.parse)(partialData);
+          const data = parseExports.parse(partialData);
           controller.enqueue(data.elements.at(-1));
           options.onFinish?.({ object: data.elements });
         },
         transform: (chunk, controller) => {
           partialData += chunk;
           try {
-            const data = (0, import_best_effort_json_parser.parse)(partialData);
+            const data = parseExports.parse(partialData);
             if (Array.isArray(Object.getOwnPropertyDescriptor(data, "elements")?.value) && data.elements.length > index + 1) {
               controller.enqueue(data.elements[index++]);
             }
@@ -316,7 +296,7 @@ async function streamObject(options) {
         transform: (chunk, controller) => {
           partialObjectData += chunk;
           try {
-            const data = (0, import_best_effort_json_parser.parse)(partialObjectData);
+            const data = parseExports.parse(partialObjectData);
             if (JSON.stringify(partialObjectSnapshot) !== JSON.stringify(data)) {
               partialObjectSnapshot = data;
               controller.enqueue(data);
@@ -335,6 +315,5 @@ async function streamObject(options) {
     };
   });
 }
-export {
-  streamObject
-};
+
+export { streamObject };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/stream-object",
   "type": "module",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.3",
   "description": "extra-small AI SDK for Browser, Node.js, Deno, Bun or Edge Runtime.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -35,11 +35,11 @@
   "devDependencies": {
     "@valibot/to-json-schema": "^1.0.0",
     "best-effort-json-parser": "^1.1.3",
-    "type-fest": "^4.35.0",
+    "type-fest": "^4.39.0",
     "valibot": "^1.0.0"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "pkgroll",
     "test": "vitest run",
     "test:watch": "vitest"
   },