immosquare-cleaner 0.1.32 → 0.1.33

data/node_modules/type-fest/source/readonly-tuple.d.ts

@@ -0,0 +1,41 @@
+/**
+Creates a read-only tuple of type `Element` and with the length of `Length`.
+
+@private
+@see `ReadonlyTuple` which is safer because it tests if `Length` is a specific finite number.
+*/
+type BuildTupleHelper<Element, Length extends number, Rest extends Element[]> =
+	Rest['length'] extends Length ?
+		readonly [...Rest] : // Terminate with readonly array (aka tuple)
+		BuildTupleHelper<Element, Length, [Element, ...Rest]>;
+
+/**
+Create a type that represents a read-only tuple of the given type and length.
+
+Use-cases:
+- Declaring fixed-length tuples with a large number of items.
+- Creating a range union (for example, `0 | 1 | 2 | 3 | 4` from the keys of such a type) without having to resort to recursive types.
+- Creating a tuple of coordinates with a static length, for example, length of 3 for a 3D vector.
+
+@example
+```
+import {ReadonlyTuple} from 'type-fest';
+
+type FencingTeam = ReadonlyTuple<string, 3>;
+
+const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
+
+const homeFencingTeam: FencingTeam = ['George', 'John'];
+//=> error TS2322: Type string[] is not assignable to type 'FencingTeam'
+
+guestFencingTeam.push('Sam');
+//=> error TS2339: Property 'push' does not exist on type 'FencingTeam'
+```
+
+@category Utilities
+*/
+export type ReadonlyTuple<Element, Length extends number> =
+	number extends Length
+		// Because `Length extends number` and `number extends Length`, then `Length` is not a specific finite number.
+		? readonly Element[] // It's not fixed length.
+		: BuildTupleHelper<Element, Length, []>; // Otherwise it is a fixed length tuple.

data/node_modules/type-fest/source/remove-index-signature.d.ts

@@ -0,0 +1,104 @@
+/**
+Remove any index signatures from the given object type, so that only explicitly defined properties remain.
+
+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 {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `RemoveIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<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.
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		as {} extends Record<KeyType, unknown>
+			? never // => Remove this `KeyType`.
+			: KeyType // => Keep this `KeyType` as it is.
+	]: ObjectType[KeyType];
+};
+```
+
+@example
+```
+import type {RemoveIndexSignature} 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 = RemoveIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@category Object
+*/
+export type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};

data/node_modules/type-fest/source/replace.d.ts

@@ -0,0 +1,67 @@
+type ReplaceOptions = {
+	all?: boolean;
+};
+
+/**
+Represents a string with some or all matches replaced by a replacement.
+
+Use-case:
+- `snake-case-path` to `dotted.path.notation`
+- Changing date/time format: `01-08-2042` → `01/08/2042`
+- Manipulation of type properties, for example, removal of prefixes
+
+@example
+```
+import {Replace} from 'type-fest';
+
+declare function replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string
+>(
+	input: Input,
+	search: Search,
+	replacement: Replacement
+): Replace<Input, Search, Replacement>;
+
+declare function replaceAll<
+	Input extends string,
+	Search extends string,
+	Replacement extends string
+>(
+	input: Input,
+	search: Search,
+	replacement: Replacement
+): Replace<Input, Search, Replacement, {all: true}>;
+
+// The return type is the exact string literal, not just `string`.
+
+replace('hello ?', '?', '🦄');
+//=> 'hello 🦄'
+
+replace('hello ??', '?', '❓');
+//=> 'hello ❓?'
+
+replaceAll('10:42:00', ':', '-');
+//=> '10-42-00'
+
+replaceAll('__userName__', '__', '');
+//=> 'userName'
+
+replaceAll('My Cool Title', ' ', '');
+//=> 'MyCoolTitle'
+```
+
+@category String
+@category Template literal
+*/
+export type Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends ReplaceOptions = {},
+> = Input extends `${infer Head}${Search}${infer Tail}`
+	? Options['all'] extends true
+		? `${Head}${Replacement}${Replace<Tail, Search, Replacement, Options>}`
+		: `${Head}${Replacement}${Tail}`
+	: Input;

data/node_modules/type-fest/source/require-all-or-none.d.ts

@@ -0,0 +1,36 @@
+/**
+Create a type that requires all of the given keys or none of the given keys. The remaining keys are kept as is.
+
+Use-cases:
+- Creating interfaces for components with mutually-inclusive keys.
+
+The caveat with `RequireAllOrNone` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireAllOrNone` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import type {RequireAllOrNone} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+	secure: boolean;
+};
+
+const responder1: RequireAllOrNone<Responder, 'text' | 'json'> = {
+	secure: true
+};
+
+const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
+	text: () => '{"message": "hi"}',
+	json: () => '{"message": "ok"}',
+	secure: true
+};
+```
+
+@category Object
+*/
+export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = never> = (
+	| Required<Pick<ObjectType, KeysType>> // Require all of the given keys.
+	| Partial<Record<KeysType, never>> // Require none of the given keys.
+) &
+	Omit<ObjectType, KeysType>; // The rest of the keys.

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

@@ -1,11 +1,11 @@
-import {Except} from './except';
+import type {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';
+import type {RequireAtLeastOne} from 'type-fest';
 
 type Responder = {
 	text?: () => string;
@@ -19,10 +19,12 @@ const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 	secure: true
 };
 ```
+
+@category Object
 */
 export type RequireAtLeastOne<
 	ObjectType,
-	KeysType extends keyof ObjectType = keyof 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

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

@@ -1,6 +1,3 @@
-// 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.
 
@@ -12,7 +9,7 @@ The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at co
 
 @example
 ```
-import {RequireExactlyOne} from 'type-fest';
+import type {RequireExactlyOne} from 'type-fest';
 
 type Responder = {
 	text: () => string;
@@ -27,9 +24,11 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 	secure: true
 };
 ```
+
+@category Object
 */
 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>;
+	)}[KeysType] & Omit<ObjectType, KeysType>;

data/node_modules/type-fest/source/required-keys-of.d.ts

@@ -0,0 +1,29 @@
+/**
+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
+*/
+export type RequiredKeysOf<BaseType extends object> = Exclude<{
+	[Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]>
+		? Key
+		: never
+}[keyof BaseType], undefined>;

data/node_modules/type-fest/source/schema.d.ts

@@ -0,0 +1,72 @@
+/**
+Create a deep version of another object type where property values are recursively replaced into a given value type.
+
+Use-cases:
+- Form validation: Define how each field should be validated.
+- Form settings: Define configuration for input fields.
+- Parsing: Define types that specify special behavior for specific fields.
+
+@example
+```
+import type {Schema} from 'type-fest';
+
+interface User {
+	id: string;
+	name: {
+		firstname: string;
+		lastname: string;
+	};
+	created: Date;
+	active: boolean;
+	passwordHash: string;
+}
+
+type UserMask = Schema<User, 'mask' | 'hide' | 'show'>;
+
+const userMaskSettings: UserMask = {
+	id: 'show',
+	name: {
+		firstname: 'show',
+		lastname: 'mask',
+	},
+	phoneNumbers: 'mask',
+	created: 'show',
+	active: 'show',
+	passwordHash: 'hide',
+}
+```
+
+@category Object
+*/
+export type Schema<ObjectType, ValueType> = ObjectType extends string
+	? ValueType
+	: ObjectType extends Map<unknown, unknown>
+	? ValueType
+	: ObjectType extends Set<unknown>
+	? ValueType
+	: ObjectType extends ReadonlyMap<unknown, unknown>
+	? ValueType
+	: ObjectType extends ReadonlySet<unknown>
+	? ValueType
+	: ObjectType extends readonly unknown[]
+	? ValueType
+	: ObjectType extends unknown[]
+	? ValueType
+	: ObjectType extends (...arguments: unknown[]) => unknown
+	? ValueType
+	: ObjectType extends Date
+	? ValueType
+	: ObjectType extends Function
+	? ValueType
+	: ObjectType extends RegExp
+	? ValueType
+	: ObjectType extends object
+	? SchemaObject<ObjectType, ValueType>
+	: ValueType;
+
+/**
+Same as `Schema`, but accepts only `object`s as inputs. Internal helper for `Schema`.
+*/
+type SchemaObject<ObjectType extends object, K> = {
+	[KeyType in keyof ObjectType]: Schema<ObjectType[KeyType], K> | K;
+};

data/node_modules/type-fest/source/screaming-snake-case.d.ts

@@ -0,0 +1,33 @@
+import type {SplitIncludingDelimiters} from './delimiter-case';
+import type {SnakeCase} from './snake-case';
+import type {Includes} from './includes';
+
+/**
+Returns a boolean for whether the string is screaming snake case.
+*/
+type IsScreamingSnakeCase<Value extends string> = Value extends Uppercase<Value>
+	? Includes<SplitIncludingDelimiters<Lowercase<Value>, '_'>, '_'> extends true
+		? true
+		: false
+	: false;
+
+/**
+Convert a string literal to screaming-snake-case.
+
+This can be useful when, for example, converting a camel-cased object property to a screaming-snake-cased SQL column name.
+
+@example
+```
+import type {ScreamingSnakeCase} from 'type-fest';
+
+const someVariable: ScreamingSnakeCase<'fooBar'> = 'FOO_BAR';
+```
+
+@category Change case
+@category Template literal
+*/
+export type ScreamingSnakeCase<Value> = Value extends string
+	? IsScreamingSnakeCase<Value> extends true
+		? Value
+		: Uppercase<SnakeCase<Value>>
+	: Value;

data/node_modules/type-fest/source/set-non-nullable.d.ts

@@ -0,0 +1,35 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+/**
+Create a type that makes the given keys non-nullable. The remaining keys are kept as is.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are non-nullable.
+
+@example
+```
+import type {SetNonNullable} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string | undefined;
+	c?: boolean | null;
+}
+
+type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
+// type SomeNonNullable = {
+// 	a: number;
+// 	b: string; // Can no longer be undefined.
+// 	c?: boolean; // Can no longer be null, but is still optional.
+// }
+```
+
+@category Object
+*/
+export type SetNonNullable<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 non-nullable from the base type and make them non-nullable.
+		{[Key in Keys]: NonNullable<BaseType[Key]>}
+	>;

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

@@ -1,4 +1,5 @@
-import {Except} from './except';
+import type {Except} from './except';
+import type {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.
@@ -7,7 +8,7 @@ Use-case: You want to define a single model where the only thing that changes is
 
 @example
 ```
-import {SetOptional} from 'type-fest';
+import type {SetOptional} from 'type-fest';
 
 type Foo = {
 	a: number;
@@ -22,13 +23,13 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 // 	c?: boolean; // Is now optional.
 // }
 ```
+
+@category Object
 */
-export type SetOptional<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-	// Pick just the keys that are not optional from the base type.
-	Except<BaseType, Keys> &
-	// Pick the keys that should be optional from the base type and make them optional.
-	Partial<Pick<BaseType, Keys>> extends
-	// If `InferredType` extends the previous, then for each key, use the inferred type key.
-	infer InferredType
-		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
-		: never;
+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>>
+	>;

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

@@ -1,4 +1,5 @@
-import {Except} from './except';
+import type {Except} from './except';
+import type {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.
@@ -7,7 +8,7 @@ Use-case: You want to define a single model where the only thing that changes is
 
 @example
 ```
-import {SetRequired} from 'type-fest';
+import type {SetRequired} from 'type-fest';
 
 type Foo = {
 	a?: number;
@@ -22,13 +23,13 @@ type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
 // 	c: boolean; // Is now required.
 // }
 ```
+
+@category Object
 */
-export type SetRequired<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-	// Pick just the keys that are not required 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>> extends
-	// If `InferredType` extends the previous, then for each key, use the inferred type key.
-	infer InferredType
-		? {[KeyType in keyof InferredType]: InferredType[KeyType]}
-		: never;
+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>>
+	>;

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

@@ -9,13 +9,15 @@ Use-case: You want to define a wrapped function that returns something different
 
 @example
 ```
-import {SetReturnType} from 'type-fest';
+import type {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;
 ```
+
+@category Function
 */
 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.

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

@@ -0,0 +1,83 @@
+/**
+@see Simplify
+*/
+export interface SimplifyOptions {
+	/**
+	Do the simplification recursively.
+
+	@default false
+	*/
+	deep?: boolean;
+}
+
+// Flatten a type without worrying about the result.
+type Flatten<
+	AnyType,
+	Options extends SimplifyOptions = {},
+> = Options['deep'] extends true
+	? {[KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options>}
+	: {[KeyType in keyof AnyType]: AnyType[KeyType]};
+
+/**
+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
+
+@category Object
+*/
+export type Simplify<
+	AnyType,
+	Options extends SimplifyOptions = {},
+> = Flatten<AnyType> extends AnyType
+	? Flatten<AnyType, Options>
+	: AnyType;