@esposter/shared 1.42.3 → 2.1.0

package/dist/index.d.ts

@@ -1,11 +1,3 @@
-//#region src/util/parseXmlString.d.ts
-declare const parseXmlString: <T extends object>(xmlString: string) => Promise<T>;
-
-//#endregion
-//#region src/util/parseXmlValue.d.ts
-declare const parseXmlValue: (value: string) => boolean | number | string;
-
-//#endregion
 //#region src/models/shared/Operation.d.ts
 declare enum Operation {
 	Create = "Create",
@@ -86,24 +78,24 @@ This is useful when you want to create a new type that contains different type v
 import type {OptionalKeysOf, Except} from 'type-fest';
 
 interface User {
-	name: string;
-	surname: string;
+name: string;
+surname: string;
 
-	luckyNumber?: number;
+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;
+[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
 };
 
 const update1: UpdateOperation<User> = {
-	name: 'Alice'
+name: 'Alice'
 };
 
 const update2: UpdateOperation<User> = {
-	name: 'Bob',
-	luckyNumber: REMOVE_FIELD
+name: 'Bob',
+luckyNumber: REMOVE_FIELD
 };
 ```
 
@@ -130,10 +122,10 @@ 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;
+name: string;
+surname: string;
 
-	luckyNumber?: number;
+luckyNumber?: number;
 }
 
 const validator1 = createValidation<User>('name', value => value.length < 25);
@@ -164,20 +156,20 @@ 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
-	>;
+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;
+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);
-	}
+if (input === output) {
+process.exit(0);
+}
 }
 
 endIfEqual('abc', 'abc');
@@ -235,7 +227,7 @@ 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];
+return obj[key];
 }
 
 const typedA = get(typedObject, 'a');
@@ -268,11 +260,11 @@ import type {IsEqual} from 'type-fest';
 // This type returns a boolean for whether the given array includes the given item.
 // `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
 type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
+Value extends readonly [Value[0], ...infer rest]
+? IsEqual<Value[0], Item> extends true
+? true
+: Includes<rest, Item>
+: false;
 ```
 
 @category Type Guard
@@ -294,13 +286,13 @@ Useful to flatten the type output to improve type hints shown in editors. And al
 import type {Simplify} from 'type-fest';
 
 type PositionProps = {
-	top: number;
-	left: number;
+top: number;
+left: number;
 };
 
 type SizeProps = {
-	width: number;
-	height: number;
+width: number;
+height: number;
 };
 
 // In your editor, hovering over `Props` will show a flattened object with all the properties.
@@ -316,15 +308,15 @@ If the type definition must be an interface (perhaps it was defined in a third-p
 import type {Simplify} from 'type-fest';
 
 interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
+foo: number;
+bar?: string;
+baz: number | undefined;
 }
 
 type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
+foo: number;
+bar?: string;
+baz: number | undefined;
 };
 
 const literal = {foo: 123, bar: 'hello', baz: 456};
@@ -372,13 +364,13 @@ Instead of causing a type error like the above, you can also use a [conditional
 
 ```
 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>`'
+: '❌ `{}` 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 assignable to `Record<'foo' | 'bar', unknown>`"
+: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
 // => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
 ```
 
@@ -388,8 +380,8 @@ Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-type
 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`.
+[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
 };
 ```
 
@@ -399,12 +391,12 @@ type OmitIndexSignature<ObjectType> = {
 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];
+[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];
 };
 ```
 
@@ -415,19 +407,19 @@ If `{}` is assignable, it means that `KeyType` is an index signature and we want
 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';
+// 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>;
@@ -457,21 +449,21 @@ 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';
+// 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>;
@@ -509,17 +501,17 @@ Merge two types into a new type. Keys of the second type overrides keys of the f
 import type {Merge} from 'type-fest';
 
 interface Foo {
-	[x: string]: unknown;
-	[x: number]: unknown;
-	foo: string;
-	bar: symbol;
+[x: string]: unknown;
+[x: number]: unknown;
+foo: string;
+bar: symbol;
 }
 
 type Bar = {
-	[x: number]: number;
-	[x: symbol]: unknown;
-	bar: Date;
-	baz: boolean;
+[x: number]: number;
+[x: symbol]: unknown;
+bar: Date;
+baz: boolean;
 };
 
 export type FooBar = Merge<Foo, Bar>;
@@ -665,33 +657,6 @@ type Filtered = Filter<'bar', 'foo'>;
 //=> 'bar'
 ```
 
-@see {Except}
-*/
-/**
-Filter out keys from an object.
-
-Returns `never` if `Exclude` is strictly equal to `Key`.
-Returns `never` if `Key` extends `Exclude`.
-Returns `Key` otherwise.
-
-@example
-```
-type Filtered = Filter<'foo', 'foo'>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', string>;
-//=> never
-```
-
-@example
-```
-type Filtered = Filter<'bar', 'foo'>;
-//=> 'bar'
-```
-
 @see {Except}
 */
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
@@ -722,8 +687,8 @@ This type was proposed to the TypeScript team, which declined it, saying they pr
 import type {Except} from 'type-fest';
 
 type Foo = {
-	a: number;
-	b: string;
+a: number;
+b: string;
 };
 
 type FooWithoutA = Except<Foo, 'a'>;
@@ -743,10 +708,10 @@ const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
 // Consider the following example:
 
 type UserData = {
-	[metadata: string]: string;
-	email: string;
-	name: string;
-	role: 'admin' | 'user';
+[metadata: string]: string;
+email: string;
+name: string;
+role: 'admin' | 'user';
 };
 
 // `Omit` clearly doesn't behave as expected in this case:
@@ -836,4 +801,4 @@ declare const UUIDV4_SEARCH_REGEX: RegExp;
 declare const uuidValidateV4: (uuid: string) => boolean;
 
 //#endregion
-export { CamelToKebab, ExcludeFunctionProperties, FunctionProperties, ID_SEPARATOR, InvalidOperationError, KebabToCamel, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, SkipFirst, TakeFirst, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, UUIDV4_SEARCH_REGEX, capitalize, exhaustiveGuard, isPlainObject, mergeObjectsStrict, parseXmlString, parseXmlValue, toKebabCase, uuidValidateV4 };
+export { CamelToKebab, ExcludeFunctionProperties, FunctionProperties, ID_SEPARATOR, InvalidOperationError, KebabToCamel, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, SkipFirst, TakeFirst, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, UUIDV4_SEARCH_REGEX, capitalize, exhaustiveGuard, isPlainObject, mergeObjectsStrict, toKebabCase, uuidValidateV4 };