immosquare-cleaner 0.1.32 → 0.1.33

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

@@ -1,67 +1,45 @@
-/// <reference lib="esnext"/>
-
-// TODO: This can just be `export type Primitive = not object` when the `not` keyword is out.
 /**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
 */
-export type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint;
+export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {prototype: T};
 
-// TODO: Remove the `= unknown` sometime  in the future when most users are on TS 3.5 as it's now the default
 /**
 Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-*/
-export type Class<T = unknown, Arguments extends any[] = any[]> = new(...arguments_: Arguments) => T;
 
-/**
-Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+@category Class
 */
-export type TypedArray =
-	| Int8Array
-	| Uint8Array
-	| Uint8ClampedArray
-	| Int16Array
-	| Uint16Array
-	| Int32Array
-	| Uint32Array
-	| Float32Array
-	| Float64Array
-	| BigInt64Array
-	| BigUint64Array;
+export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
 
 /**
 Matches a JSON object.
 
 This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+
+@category JSON
 */
 export type JsonObject = {[Key in string]?: JsonValue};
 
 /**
 Matches a JSON array.
+
+@category JSON
 */
-export interface JsonArray extends Array<JsonValue> {}
+export type JsonArray = JsonValue[];
 
 /**
-Matches any valid JSON value.
-*/
-export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+Matches any valid JSON primitive value.
 
-declare global {
-	interface SymbolConstructor {
-		readonly observable: symbol;
-	}
-}
+@category JSON
+*/
+export type JsonPrimitive = string | number | boolean | null;
 
 /**
-Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
+Matches any valid JSON value.
+
+@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
+
+@category JSON
 */
-export interface ObservableLike {
-	subscribe(observer: (value: unknown) => void): void;
-	[Symbol.observable](): ObservableLike;
-}
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

data/node_modules/type-fest/{ts41 → source}/camel-case.d.ts

@@ -1,13 +1,5 @@
-import {WordSeparators} from '../source/utilities';
-
-/**
-Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
-*/
-export type Split<S extends string, D extends string> =
-	string extends S ? string[] :
-	S extends '' ? [] :
-	S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
-	[S];
+import type {WordSeparators} from '../source/internal';
+import type {Split} from './split';
 
 /**
 Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
@@ -16,7 +8,7 @@ Only to be used by `CamelCaseStringArray<>`.
 
 @see CamelCaseStringArray
 */
-type InnerCamelCaseStringArray<Parts extends any[], PreviousPart> =
+type InnerCamelCaseStringArray<Parts extends readonly any[], PreviousPart> =
 	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
 		? FirstPart extends undefined
 			? ''
@@ -32,7 +24,7 @@ It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to
 
 @see Split
 */
-type CamelCaseStringArray<Parts extends string[]> =
+type CamelCaseStringArray<Parts extends readonly string[]> =
 	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
 		? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`>
 		: never;
@@ -44,7 +36,7 @@ This can be useful when, for example, converting some kebab-cased command-line f
 
 @example
 ```
-import {CamelCase} from 'type-fest';
+import type {CamelCase} from 'type-fest';
 
 // Simple
 
@@ -52,7 +44,7 @@ const someVariable: CamelCase<'foo-bar'> = 'fooBar';
 
 // Advanced
 
-type CamelCasedProps<T> = {
+type CamelCasedProperties<T> = {
 	[K in keyof T as CamelCase<K>]: T[K]
 };
 
@@ -60,13 +52,22 @@ interface RawOptions {
 	'dry-run': boolean;
 	'full_family_name': string;
 	foo: number;
+	BAR: string;
+	QUZ_QUX: number;
+	'OTHER-FIELD': boolean;
 }
 
-const dbResult: CamelCasedProps<ModelProps> = {
+const dbResult: CamelCasedProperties<RawOptions> = {
 	dryRun: true,
 	fullFamilyName: 'bar.js',
-	foo: 123
+	foo: 123,
+	bar: 'foo',
+	quzQux: 6,
+	otherField: false
 };
 ```
+
+@category Change case
+@category Template literal
 */
-export type CamelCase<K> = K extends string ? CamelCaseStringArray<Split<K, WordSeparators>> : K;
+export type CamelCase<K> = K extends string ? CamelCaseStringArray<Split<K extends Uppercase<K> ? Lowercase<K> : K, WordSeparators>> : K;

data/node_modules/type-fest/source/camel-cased-properties-deep.d.ts

@@ -0,0 +1,54 @@
+import type {CamelCase} from './camel-case';
+
+/**
+Convert object properties to camel case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see CamelCasedProperties
+@see CamelCase
+
+@example
+```
+import type {CamelCasedPropertiesDeep} from 'type-fest';
+
+interface User {
+	UserId: number;
+	UserName: string;
+}
+
+interface UserWithFriends {
+	UserInfo: User;
+	UserFriends: User[];
+}
+
+const result: CamelCasedPropertiesDeep<UserWithFriends> = {
+	userInfo: {
+		userId: 1,
+		userName: 'Tom',
+	},
+	userFriends: [
+		{
+			userId: 2,
+			userName: 'Jerry',
+		},
+		{
+			userId: 3,
+			userName: 'Spike',
+		},
+	],
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type CamelCasedPropertiesDeep<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
+	? Array<CamelCasedPropertiesDeep<U>>
+	: Value extends Set<infer U>
+	? Set<CamelCasedPropertiesDeep<U>> : {
+			[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
+	};

data/node_modules/type-fest/source/camel-cased-properties.d.ts

@@ -0,0 +1,36 @@
+import type {CamelCase} from './camel-case';
+
+/**
+Convert object properties to camel case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see CamelCasedPropertiesDeep
+@see CamelCase
+
+@example
+```
+import type {CamelCasedProperties} from 'type-fest';
+
+interface User {
+	UserId: number;
+	UserName: string;
+}
+
+const result: CamelCasedProperties<User> = {
+	userId: 1,
+	userName: 'Tom',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type CamelCasedProperties<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
+	? Value
+	: {
+			[K in keyof Value as CamelCase<K>]: Value[K];
+	};

data/node_modules/type-fest/source/conditional-except.d.ts

@@ -1,5 +1,5 @@
-import {Except} from './except';
-import {ConditionalKeys} from './conditional-keys';
+import type {Except} from './except';
+import type {ConditionalKeys} from './conditional-keys';
 
 /**
 Exclude keys from a shape that matches the given `Condition`.
@@ -8,7 +8,7 @@ This is useful when you want to create a new type with a specific set of keys fr
 
 @example
 ```
-import {Primitive, ConditionalExcept} from 'type-fest';
+import type {Primitive, ConditionalExcept} from 'type-fest';
 
 class Awesome {
 	name: string;
@@ -24,7 +24,7 @@ type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
 
 @example
 ```
-import {ConditionalExcept} from 'type-fest';
+import type {ConditionalExcept} from 'type-fest';
 
 interface Example {
 	a: string;
@@ -36,6 +36,8 @@ interface Example {
 type NonStringKeysOnly = ConditionalExcept<Example, string>;
 //=> {b: string | number; c: () => void; d: {}}
 ```
+
+@category Object
 */
 export type ConditionalExcept<Base, Condition> = Except<
 	Base,

data/node_modules/type-fest/source/conditional-keys.d.ts

@@ -5,7 +5,7 @@ Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
 
 @example
 ```
-import {ConditionalKeys} from 'type-fest';
+import type {ConditionalKeys} from 'type-fest';
 
 interface Example {
 	a: string;
@@ -22,9 +22,13 @@ To support partial types, make sure your `Condition` is a union of undefined (fo
 
 @example
 ```
+import type {ConditionalKeys} from 'type-fest';
+
 type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
 //=> 'a' | 'c'
 ```
+
+@category Object
 */
 export type ConditionalKeys<Base, Condition> = NonNullable<
 	// Wrap in `NonNullable` to strip away the `undefined` type from the produced union.

data/node_modules/type-fest/source/conditional-pick.d.ts

@@ -1,4 +1,4 @@
-import {ConditionalKeys} from './conditional-keys';
+import type {ConditionalKeys} from './conditional-keys';
 
 /**
 Pick keys from the shape that matches the given `Condition`.
@@ -7,7 +7,7 @@ This is useful when you want to create a new type from a specific subset of an e
 
 @example
 ```
-import {Primitive, ConditionalPick} from 'type-fest';
+import type {Primitive, ConditionalPick} from 'type-fest';
 
 class Awesome {
 	name: string;
@@ -23,7 +23,7 @@ type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
 
 @example
 ```
-import {ConditionalPick} from 'type-fest';
+import type {ConditionalPick} from 'type-fest';
 
 interface Example {
 	a: string;
@@ -35,6 +35,8 @@ interface Example {
 type StringKeysOnly = ConditionalPick<Example, string>;
 //=> {a: string}
 ```
+
+@category Object
 */
 export type ConditionalPick<Base, Condition> = Pick<
 	Base,

data/node_modules/type-fest/{ts41 → source}/delimiter-case.d.ts

@@ -1,7 +1,9 @@
-import {UpperCaseCharacters, WordSeparators} from '../source/utilities';
+import type {UpperCaseCharacters, WordSeparators} from '../source/internal';
 
 /**
 Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+
+@category Template literal
 */
 export type SplitIncludingDelimiters<Source extends string, Delimiter extends string> =
 	Source extends '' ? [] :
@@ -22,8 +24,9 @@ Format a specific part of the splitted string literal that `StringArrayToDelimit
 
 @see StringArrayToDelimiterCase
 */
-type StringPartToDelimiterCase<StringPart extends string, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+type StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
 	StringPart extends UsedWordSeparators ? Delimiter :
+	Start extends true ? Lowercase<StringPart> :
 	StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` :
 	StringPart;
 
@@ -34,9 +37,11 @@ It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensur
 
 @see SplitIncludingDelimiters
 */
-type StringArrayToDelimiterCase<Parts extends any[], UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+type StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
 	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
-		? `${StringPartToDelimiterCase<FirstPart, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
+		? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
+		: Parts extends [string]
+		? string
 		: '';
 
 /**
@@ -49,7 +54,7 @@ This can be useful when, for example, converting a camel-cased object property t
 
 @example
 ```
-import {DelimiterCase} from 'type-fest';
+import type {DelimiterCase} from 'type-fest';
 
 // Simple
 
@@ -57,7 +62,7 @@ const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
 
 // Advanced
 
-type OddlyCasedProps<T> = {
+type OddlyCasedProperties<T> = {
 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
 };
 
@@ -67,17 +72,20 @@ interface SomeOptions {
 	foo: number;
 }
 
-const rawCliOptions: OddlyCasedProps<SomeOptions> = {
+const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
 	'dry#run': true,
 	'include#file': 'bar.js',
 	foo: 123
 };
 ```
-*/
 
+@category Change case
+@category Template literal
+*/
 export type DelimiterCase<Value, Delimiter extends string> = Value extends string
 	? StringArrayToDelimiterCase<
 		SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
+		true,
 		WordSeparators,
 		UpperCaseCharacters,
 		Delimiter

data/node_modules/type-fest/source/delimiter-cased-properties-deep.d.ts

@@ -0,0 +1,60 @@
+import type {DelimiterCase} from './delimiter-case';
+
+/**
+Convert object properties to delimiter case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see DelimiterCase
+@see DelimiterCasedProperties
+
+@example
+```
+import type {DelimiterCasedPropertiesDeep} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
+	'user-info': {
+	'user-id': 1,
+		'user-name': 'Tom',
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry',
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike',
+		},
+	],
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type DelimiterCasedPropertiesDeep<
+	Value,
+	Delimiter extends string,
+> = Value extends Function | Date | RegExp
+	? Value
+	: Value extends Array<infer U>
+	? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
+	: Value extends Set<infer U>
+	? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
+			[K in keyof Value as DelimiterCase<
+				K,
+				Delimiter
+			>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
+	};

data/node_modules/type-fest/source/delimiter-cased-properties.d.ts

@@ -0,0 +1,37 @@
+import type {DelimiterCase} from './delimiter-case';
+
+/**
+Convert object properties to delimiter case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see DelimiterCase
+@see DelimiterCasedPropertiesDeep
+
+@example
+```
+import type {DelimiterCasedProperties} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+const result: DelimiterCasedProperties<User, '-'> = {
+	'user-id': 1,
+	'user-name': 'Tom',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type DelimiterCasedProperties<
+	Value,
+	Delimiter extends string,
+> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
+	? Value
+	: {[K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K]};

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

@@ -1,4 +1,4 @@
-import {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry';
+import type {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry';
 
 type ArrayEntries<BaseType extends readonly unknown[]> = Array<ArrayEntry<BaseType>>;
 type MapEntries<BaseType> = Array<MapEntry<BaseType>>;
@@ -14,7 +14,7 @@ For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/R
 
 @example
 ```
-import {Entries} from 'type-fest';
+import type {Entries} from 'type-fest';
 
 interface Example {
 	someKey: number;
@@ -48,10 +48,15 @@ const mapEntries: Entries<typeof map> = [['a', 1]];
 const setExample = new Set(['a', 1]);
 const setEntries: Entries<typeof setExample> = [['a', 'a'], [1, 1]];
 ```
+
+@category Object
+@category Map
+@category Set
+@category Array
 */
 export type Entries<BaseType> =
 	BaseType extends Map<unknown, unknown> ? MapEntries<BaseType>
 		: BaseType extends Set<unknown> ? SetEntries<BaseType>
-		: BaseType extends unknown[] ? ArrayEntries<BaseType>
+		: BaseType extends readonly unknown[] ? ArrayEntries<BaseType>
 		: BaseType extends object ? ObjectEntries<BaseType>
 		: never;

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

@@ -15,7 +15,7 @@ For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/R
 
 @example
 ```
-import {Entry} from 'type-fest';
+import type {Entry} from 'type-fest';
 
 interface Example {
 	someKey: number;
@@ -44,17 +44,22 @@ const arrayEntryNumber: Entry<typeof arrayExample> = [1, 1];
 
 // Maps
 const mapExample = new Map([['a', 1]]);
-const mapEntry: Entry<typeof map> = ['a', 1];
+const mapEntry: Entry<typeof mapExample> = ['a', 1];
 
 // Sets
 const setExample = new Set(['a', 1]);
 const setEntryString: Entry<typeof setExample> = ['a', 'a'];
 const setEntryNumber: Entry<typeof setExample> = [1, 1];
 ```
+
+@category Object
+@category Map
+@category Array
+@category Set
 */
 export type Entry<BaseType> =
 	BaseType extends Map<unknown, unknown> ? MapEntry<BaseType>
 		: BaseType extends Set<unknown> ? SetEntry<BaseType>
-		: BaseType extends unknown[] ? ArrayEntry<BaseType>
+		: BaseType extends readonly unknown[] ? ArrayEntry<BaseType>
 		: BaseType extends object ? ObjectEntry<BaseType>
 		: never;

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

@@ -0,0 +1,73 @@
+import type {KeysOfUnion} from './internal';
+
+/**
+Extract the element of an array that also works for array union.
+
+Returns `never` if T is not an array.
+
+It creates a type-safe way to access the element type of `unknown` type.
+*/
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+
+/**
+Extract the object field type if T is an object and K is a key of T, return `never` otherwise.
+
+It creates a type-safe way to access the member type of `unknown` type.
+*/
+type ObjectValue<T, K> = K extends keyof T ? T[K] : never;
+
+/**
+Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
+- Generate a list of keys that exists in `InputType` but not in `ParameterType`.
+- Mark these excess keys as `never`.
+*/
+type ExactObject<ParameterType, InputType> = {[Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>}
+	& Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+
+/**
+Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.
+
+This is useful for function type-guarding to reject arguments with excess properties. Due to the nature of TypeScript, it does not complain if excess properties are provided unless the provided value is an object literal.
+
+*Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/12936) if you want to have this type as a built-in in TypeScript.*
+
+@example
+```
+type OnlyAcceptName = {name: string};
+
+function onlyAcceptName(args: OnlyAcceptName) {}
+
+// TypeScript complains about excess properties when an object literal is provided.
+onlyAcceptName({name: 'name', id: 1});
+//=> `id` is excess
+
+// TypeScript does not complain about excess properties when the provided value is a variable (not an object literal).
+const invalidInput = {name: 'name', id: 1};
+onlyAcceptName(invalidInput); // No errors
+```
+
+Having `Exact` allows TypeScript to reject excess properties.
+
+@example
+```
+import {Exact} from 'type-fest';
+
+type OnlyAcceptName = {name: string};
+
+function onlyAcceptNameImproved<T extends Exact<OnlyAcceptName, T>>(args: T) {}
+
+const invalidInput = {name: 'name', id: 1};
+onlyAcceptNameImproved(invalidInput); // Compilation error
+```
+
+[Read more](https://stackoverflow.com/questions/49580725/is-it-possible-to-restrict-typescript-object-to-contain-only-properties-defined)
+
+@category Utilities
+*/
+export type Exact<ParameterType, InputType> =
+	// Convert union of array to array of union: A[] & B[] => (A & B)[]
+	ParameterType extends unknown[] ? Array<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+	// In TypeScript, Array is a subtype of ReadonlyArray, so always test Array before ReadonlyArray.
+	: ParameterType extends readonly unknown[] ? ReadonlyArray<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+	: ParameterType extends object ? ExactObject<ParameterType, InputType>
+	: ParameterType;