@esposter/shared 2.1.0 → 2.2.1

package/README.md

@@ -0,0 +1,17 @@
+# @esposter/shared
+
+[![Apache-2.0 licensed][badge-license]][url-license]
+[![NPM version][badge-npm-version]][url-npm]
+[![NPM downloads][badge-npm-downloads]][url-npm]
+[![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
+
+## <a name="license">⚖️ License</a>
+
+This project is licensed under the [Apache-2.0 license](https://github.com/Esposter/Esposter/blob/main/LICENSE).
+
+[badge-license]: https://img.shields.io/github/license/Esposter/Esposter.svg?color=blue
+[url-license]: https://github.com/Esposter/Esposter/blob/main/LICENSE
+[badge-npm-version]: https://img.shields.io/npm/v/@esposter/shared/latest?color=brightgreen
+[url-npm]: https://www.npmjs.com/package/@esposter/shared/v/latest
+[badge-npm-unpacked-size]: https://img.shields.io/npm/unpacked-size/@esposter/shared/latest?label=npm
+[badge-npm-downloads]: https://img.shields.io/npm/dm/@esposter/shared.svg

package/dist/index.d.ts

@@ -1,28 +1,26 @@
 //#region src/models/shared/Operation.d.ts
 declare enum Operation {
-	Create = "Create",
-	Delete = "Delete",
-	Push = "Push",
-	Read = "Read",
-	Update = "Update"
-}
-
-//#endregion
+  Create = "Create",
+  Delete = "Delete",
+  Push = "Push",
+  Read = "Read",
+  Update = "Update",
+} //#endregion
 //#region src/models/error/InvalidOperationError.d.ts
 declare class InvalidOperationError extends Error {
-	constructor(operation: Operation, name: string, message: string);
+  constructor(operation: Operation, name: string, message: string);
 }
 
 //#endregion
 //#region src/models/error/NotFoundError.d.ts
 declare class NotFoundError<T extends string = string> extends Error {
-	constructor(name: T, id: string);
+  constructor(name: T, id: string);
 }
 
 //#endregion
 //#region src/models/error/NotInitializedError.d.ts
 declare class NotInitializedError<T extends string = string> extends Error {
-	constructor(name: T);
+  constructor(name: T);
 }
 
 //#endregion
@@ -35,7 +33,7 @@ declare const isPlainObject: (data: unknown) => data is object;
 
 //#endregion
 //#region src/util/types/MergeObjectsStrict.d.ts
-type MergeObjectsStrict<T extends object[]> = T extends [infer TFirst, infer TSecond, ...infer TRemaining] ? TSecond extends { [K in keyof TSecond] : K extends keyof TFirst ? never : TSecond[K] } ? TRemaining extends object[] ? MergeObjectsStrict<[TSecond, ...TRemaining]> & TFirst : TFirst & TSecond : never : T extends [infer TFirst] ? TFirst : never;
+type MergeObjectsStrict<T extends object[]> = T extends [infer TFirst, infer TSecond, ...infer TRemaining] ? TSecond extends { [K in keyof TSecond]: K extends keyof TFirst ? never : TSecond[K] } ? TRemaining extends object[] ? MergeObjectsStrict<[TSecond, ...TRemaining]> & TFirst : TFirst & TSecond : never : T extends [infer TFirst] ? TFirst : never;
 
 //#endregion
 //#region src/util/object/mergeObjectsStrict.d.ts
@@ -55,19 +53,30 @@ declare const toKebabCase: <T extends string>(string: T) => CamelToKebab<T>;
 
 //#endregion
 //#region src/util/types/FunctionProperties.d.ts
-type FunctionProperties<T> = { [K in keyof T] : T[K] extends Function ? K : never };
+type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never };
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/observable-like.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/observable-like.d.ts
 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;
-	}
+  // 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;
+  }
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+
 /**
 Extract all optional keys from the given type.
 
@@ -78,38 +87,36 @@ 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
 };
 ```
 
 @category Utilities
 */
-type OptionalKeysOf<BaseType extends object> =
-	BaseType extends unknown // For distributing `BaseType`
-		? (keyof {
-			[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never
-		}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
-		: never;
+type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+: never;
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/required-keys-of.d.ts
+// Should never happen
 /**
 Extract all required keys from the given type.
 
@@ -122,10 +129,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);
@@ -134,13 +141,13 @@ 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;
+type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-never.d.ts
+// Should never happen
+
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -156,20 +163,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');
@@ -185,7 +192,7 @@ endIfEqual('abc', '123');
 type IsNever<T> = [T] extends [never] ? true : false;
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/if-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-never.d.ts
 /**
 An if-else-like type that resolves depending on whether the given type is `never`.
 
@@ -205,13 +212,14 @@ type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
 @category Type Guard
 @category Utilities
 */
-type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
-	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
-);
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/is-any.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-any.d.ts
+// 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`.
 
@@ -227,7 +235,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');
@@ -243,7 +251,7 @@ const anyA = get(anyObject, 'a');
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/is-equal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -260,24 +268,20 @@ 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
 @category Utilities
 */
-type IsEqual<A, B> =
-	(<G>() => G extends A & G | G ? 1 : 2) extends
-	(<G>() => G extends B & G | G ? 1 : 2)
-		? true
-		: false;
+type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/simplify.d.ts
 /**
 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.
 
@@ -286,13 +290,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.
@@ -308,15 +312,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};
@@ -335,10 +339,10 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see SimplifyDeep
 @category Object
 */
-type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -364,13 +368,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>`"
 ```
 
@@ -380,8 +384,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`.
 };
 ```
 
@@ -391,12 +395,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];
 };
 ```
 
@@ -407,19 +411,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>;
@@ -429,14 +433,10 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 @see PickIndexSignature
 @category Object
 */
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? never
-		: KeyType]: ObjectType[KeyType];
-};
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -449,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>;
@@ -482,17 +482,13 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 @see OmitIndexSignature
 @category Object
 */
-type PickIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-		? KeyType
-		: never]: ObjectType[KeyType];
-};
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/merge.d.ts
-type SimpleMerge<Destination, Source> = {
-	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
-} & Source;
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/merge.d.ts
+// 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.
 
@@ -501,17 +497,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>;
@@ -527,14 +523,10 @@ export type FooBar = Merge<Foo, Bar>;
 
 @category Object
 */
-type Merge<Destination, Source> =
-Simplify<
-SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
-& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
->;
+type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/if-any.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-any.d.ts
 /**
 An if-else-like type that resolves depending on whether the given type is `any`.
 
@@ -554,12 +546,10 @@ type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
 @category Type Guard
 @category Utilities
 */
-type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (
-	IsAny<T> extends true ? TypeIfAny : TypeIfNotAny
-);
+type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
 
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/object.d.ts
 /**
 Merges user specified options with default options.
 
@@ -612,26 +602,11 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // 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>`
-	>>;
-
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.40.0/node_modules/type-fest/source/except.d.ts
+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>`
+>>;
+
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -661,18 +636,17 @@ type Filtered = Filter<'bar', 'foo'>;
 */
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 type ExceptOptions = {
-	/**
-	Disallow assigning non-specified properties.
-
-	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-
-	@default false
-	*/
-	requireExactProps?: boolean;
+  /**
+  Disallow assigning non-specified properties.
+  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  	@default false
+  */
+  requireExactProps?: boolean;
 };
 type DefaultExceptOptions = {
-	requireExactProps: false;
+  requireExactProps: false;
 };
+
 /**
 Create a type from an object type without certain keys.
 
@@ -687,8 +661,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'>;
@@ -708,10 +682,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:
@@ -726,13 +700,8 @@ type PostPayload = Except<UserData, 'email'>;
 
 @category Object
 */
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> =
-	_Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
-	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-} & (Options['requireExactProps'] extends true
-	? Partial<Record<KeysType, never>>
-	: {});
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 
 //#endregion
 //#region src/util/types/ExcludeFunctionProperties.d.ts
@@ -744,47 +713,27 @@ type KebabToCamel<S extends string> = S extends `${infer T}-${infer U}` ? `${T}$
 
 //#endregion
 //#region src/util/types/TupleSplitHead.d.ts
-type TupleSplitHead<
-	T extends unknown[],
-	N extends number
-> = T["length"] extends N ? T : T extends [...infer R, unknown] ? TupleSplitHead<R, N> : never;
+type TupleSplitHead<T extends unknown[], N extends number> = T["length"] extends N ? T : T extends [...infer R, unknown] ? TupleSplitHead<R, N> : never;
 
 //#endregion
 //#region src/util/types/TupleSplitTail.d.ts
-type TupleSplitTail<
-	T,
-	N extends number,
-	O extends unknown[] = []
-> = O["length"] extends N ? T : T extends [infer F, ...infer R] ? TupleSplitTail<[...R], N, [...O, F]> : never;
+type TupleSplitTail<T, N extends number, O extends unknown[] = []> = O["length"] extends N ? T : T extends [infer F, ...infer R] ? TupleSplitTail<[...R], N, [...O, F]> : never;
 
 //#endregion
 //#region src/util/types/TupleSplit.d.ts
-type TupleSplit<
-	T extends unknown[],
-	N extends number
-> = [TupleSplitHead<T, N>, TupleSplitTail<T, N>];
+type TupleSplit<T extends unknown[], N extends number> = [TupleSplitHead<T, N>, TupleSplitTail<T, N>];
 
 //#endregion
 //#region src/util/types/SkipFirst.d.ts
-type SkipFirst<
-	T extends unknown[],
-	N extends number
-> = TupleSplit<T, N>[1];
+type SkipFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
 
 //#endregion
 //#region src/util/types/TakeFirst.d.ts
-type TakeFirst<
-	T extends unknown[],
-	N extends number
-> = TupleSplit<T, N>[0];
+type TakeFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[0];
 
 //#endregion
 //#region src/util/types/TupleSlice.d.ts
-type TupleSlice<
-	T extends unknown[],
-	S extends number,
-	E extends number = T["length"]
-> = SkipFirst<TakeFirst<T, E>, S>;
+type TupleSlice<T extends unknown[], S extends number, E extends number = T["length"]> = SkipFirst<TakeFirst<T, E>, S>;
 
 //#endregion
 //#region src/util/validation/exhaustiveGuard.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esposter/shared",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "A library that contains shared typescript code.",
   "type": "module",
   "homepage": "https://github.com/Esposter/Esposter#readme",
@@ -11,6 +11,9 @@
   "files": [
     "dist"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Esposter/Esposter.git"
@@ -25,5 +28,5 @@
     "typecheck": "tsc",
     "export:gen": "ctix build --config ../configuration/.ctirc-ts"
   },
-  "gitHead": "d66b743bdd09c938a75bf255cd62cbbcb7e17bd6"
+  "gitHead": "fa26fdd42414351b77bd9cf2f9a7b42cc78064c7"
 }