create-openclaw-bot 5.2.0 → 5.2.1

package/node_modules/type-fest/source/promise-value.d.ts

@@ -0,0 +1,27 @@
+/**
+Returns the type that is wrapped inside a `Promise` type.
+If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
+If the type is not a `Promise`, the type itself is returned.
+
+@example
+```
+import {PromiseValue} from 'type-fest';
+
+type AsyncData = Promise<string>;
+let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
+
+type Data = PromiseValue<AsyncData>;
+let data: Data = await asyncData;
+
+// Here's an example that shows how this type reacts to non-Promise types.
+type SyncData = PromiseValue<string>;
+let syncData: SyncData = getSyncData();
+
+// Here's an example that shows how this type reacts to recursive Promise types.
+type RecursiveAsyncData = Promise<Promise<string> >;
+let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
+```
+*/
+export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<infer Value>
+	? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
+	: Otherwise;

package/node_modules/type-fest/source/readonly-deep.d.ts

@@ -0,0 +1,59 @@
+import {Primitive} from './basic';
+
+/**
+Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+
+This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	"foo": ["bar"]
+}
+
+// main.ts
+import {ReadonlyDeep} from 'type-fest';
+import dataJson = require('./data.json');
+
+const data: ReadonlyDeep<typeof dataJson> = dataJson;
+
+export default data;
+
+// test.ts
+import data from './main';
+
+data.foo.push('bar');
+//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
+```
+*/
+export type ReadonlyDeep<T> = T extends Primitive | ((...arguments: any[]) => unknown)
+	? T
+	: T extends ReadonlyMap<infer KeyType, infer ValueType>
+	? ReadonlyMapDeep<KeyType, ValueType>
+	: T extends ReadonlySet<infer ItemType>
+	? ReadonlySetDeep<ItemType>
+	: T extends object
+	? ReadonlyObjectDeep<T>
+	: unknown;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+interface ReadonlyMapDeep<KeyType, ValueType>
+	extends ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>> {}
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+interface ReadonlySetDeep<ItemType>
+	extends ReadonlySet<ReadonlyDeep<ItemType>> {}
+
+/**
+Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyObjectDeep<ObjectType extends object> = {
+	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
+};

package/node_modules/type-fest/source/require-at-least-one.d.ts

@@ -0,0 +1,33 @@
+import {Except} from './except';
+
+/**
+Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+
+@example
+```
+import {RequireAtLeastOne} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+
+	secure?: boolean;
+};
+
+const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+*/
+export type RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType = keyof ObjectType
+> = {
+	// For each `Key` in `KeysType` make a mapped type:
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
+		// 2. Make all other keys in `KeysType` optional
+		Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+}[KeysType] &
+	// 3. Add the remaining keys not in `KeysType`
+	Except<ObjectType, KeysType>;

package/node_modules/type-fest/source/require-exactly-one.d.ts

@@ -0,0 +1,35 @@
+// TODO: Remove this when we target TypeScript >=3.5.
+type _Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+
+/**
+Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
+
+Use-cases:
+- Creating interfaces for components that only need one of the keys to display properly.
+- Declaring generic keys in a single place for a single use-case that gets narrowed down via `RequireExactlyOne`.
+
+The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireExactlyOne` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import {RequireExactlyOne} from 'type-fest';
+
+type Responder = {
+	text: () => string;
+	json: () => string;
+	secure: boolean;
+};
+
+const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
+	// Adding a `text` key here would cause a compile error.
+
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+*/
+export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	{[Key in KeysType]: (
+		Required<Pick<ObjectType, Key>> &
+		Partial<Record<Exclude<KeysType, Key>, never>>
+	)}[KeysType] & _Omit<ObjectType, KeysType>;

package/node_modules/type-fest/source/set-optional.d.ts

@@ -0,0 +1,33 @@
+import {Except} from './except';
+import {Simplify} from './simplify';
+
+/**
+Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
+
+@example
+```
+import {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+}
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+// type SomeOptional = {
+// 	a: number;
+// 	b?: string; // Was already optional and still is.
+// 	c?: boolean; // Is now optional.
+// }
+```
+*/
+export type SetOptional<BaseType, Keys extends keyof BaseType> =
+	Simplify<
+		// Pick just the keys that are readonly from the base type.
+		Except<BaseType, Keys> &
+		// Pick the keys that should be mutable from the base type and make them mutable.
+		Partial<Pick<BaseType, Keys>>
+	>;

package/node_modules/type-fest/source/set-required.d.ts

@@ -0,0 +1,33 @@
+import {Except} from './except';
+import {Simplify} from './simplify';
+
+/**
+Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
+
+@example
+```
+import {SetRequired} from 'type-fest';
+
+type Foo = {
+	a?: number;
+	b: string;
+	c?: boolean;
+}
+
+type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
+// type SomeRequired = {
+// 	a?: number;
+// 	b: string; // Was already required and still is.
+// 	c: boolean; // Is now required.
+// }
+```
+*/
+export type SetRequired<BaseType, Keys extends keyof BaseType> =
+	Simplify<
+		// Pick just the keys that are optional from the base type.
+		Except<BaseType, Keys> &
+		// Pick the keys that should be required from the base type and make them required.
+		Required<Pick<BaseType, Keys>>
+	>;

package/node_modules/type-fest/source/set-return-type.d.ts

@@ -0,0 +1,29 @@
+type IsAny<T> = 0 extends (1 & T) ? true : false; // https://stackoverflow.com/a/49928360/3406963
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUnknown<T> = IsNever<T> extends false ? T extends unknown ? unknown extends T ? IsAny<T> extends false ? true : false : false : false : false;
+
+/**
+Create a function type with a return type of your choice and the same parameters as the given function type.
+
+Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+
+@example
+```
+import {SetReturnType} from 'type-fest';
+
+type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
+
+type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
+//=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
+```
+*/
+export type SetReturnType<Fn extends (...args: any[]) => any, TypeToReturn> =
+	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
+	Fn extends (this: infer ThisArg, ...args: infer Arguments) => any ? (
+		// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
+		// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
+		IsUnknown<ThisArg> extends true ? (...args: Arguments) => TypeToReturn : (this: ThisArg, ...args: Arguments) => TypeToReturn
+	) : (
+		// This part should be unreachable, but we make it meaningful just in case…
+		(...args: Parameters<Fn>) => TypeToReturn
+	);

package/node_modules/type-fest/source/simplify.d.ts

@@ -0,0 +1,4 @@
+/**
+Flatten the type output to improve type hints shown in editors.
+*/
+export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

package/node_modules/type-fest/source/stringified.d.ts

@@ -0,0 +1,21 @@
+/**
+Create a type with the keys of the given type changed to `string` type.
+
+Use-case: Changing interface values to strings in order to use them in a form model.
+
+@example
+```
+import {Stringified} from 'type-fest';
+
+type Car {
+	model: string;
+	speed: number;
+}
+
+const carForm: Stringified<Car> = {
+	model: 'Foo',
+	speed: '101'
+};
+```
+*/
+export type Stringified<ObjectType> = {[KeyType in keyof ObjectType]: string};