@jakubmazanec/ts-utils 1.0.0-fdb1c25

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2022 Jakub Mazanec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './utils.js';

package/dist/main.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./utils.js";
+
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/main.ts"],"sourcesContent":["export * from './types.js';\nexport * from './utils.js';\n"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/types/AtLeastOneRequired.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Constructs new type from `T` so that at least one property from the set of properties `P` is required:
+ *
+ * ```TypeScript
+ * import { AtLeastOneRequired } from '@ori/ts-utils';
+ *
+ * type FooOrBar = AtLeastOneRequired<{foo: string; bar: string; qux: string}, 'foo' | 'bar'>;
+ *
+ * const fooOrBar1: FooOrBar = {
+ *   foo: 'this is required',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar2: FooOrBar = {
+ *   bar: 'or this is required',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar3: FooOrBar = {
+ *   foo: 'we can have foo',
+ *   bar: 'and bar',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar4: FooOrBar = {
+ *   // no foo nor bar
+ *   qux: 'this always required',
+ * }; // error TS2322: Type '{ qux: string; }' is not assignable to type 'FooOrBar'
+ * ```
+ *
+ * @typeParam T Base for the new type
+ * @typeParam P String literal or union of string literals specifying properties of `T`
+ */
+export declare type AtLeastOneRequired<T, P extends keyof T = keyof T> = {
+    [K in P]-?: Partial<Pick<T, Exclude<P, K>>> & Required<Pick<T, K>>;
+}[P] & Pick<T, Exclude<keyof T, P>>;

package/dist/types/AtLeastOneRequired.js

@@ -0,0 +1,35 @@
+/**
+ * Constructs new type from `T` so that at least one property from the set of properties `P` is required:
+ *
+ * ```TypeScript
+ * import { AtLeastOneRequired } from '@ori/ts-utils';
+ *
+ * type FooOrBar = AtLeastOneRequired<{foo: string; bar: string; qux: string}, 'foo' | 'bar'>;
+ *
+ * const fooOrBar1: FooOrBar = {
+ *   foo: 'this is required',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar2: FooOrBar = {
+ *   bar: 'or this is required',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar3: FooOrBar = {
+ *   foo: 'we can have foo',
+ *   bar: 'and bar',
+ *   qux: 'this always required',
+ * };
+ *
+ * const fooOrBar4: FooOrBar = {
+ *   // no foo nor bar
+ *   qux: 'this always required',
+ * }; // error TS2322: Type '{ qux: string; }' is not assignable to type 'FooOrBar'
+ * ```
+ *
+ * @typeParam T Base for the new type
+ * @typeParam P String literal or union of string literals specifying properties of `T`
+ */ export { };
+
+//# sourceMappingURL=AtLeastOneRequired.js.map

package/dist/types/AtLeastOneRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/AtLeastOneRequired.ts"],"sourcesContent":["/**\n * Constructs new type from `T` so that at least one property from the set of properties `P` is required:\n *\n * ```TypeScript\n * import { AtLeastOneRequired } from '@ori/ts-utils';\n *\n * type FooOrBar = AtLeastOneRequired<{foo: string; bar: string; qux: string}, 'foo' | 'bar'>;\n *\n * const fooOrBar1: FooOrBar = {\n *   foo: 'this is required',\n *   qux: 'this always required',\n * };\n *\n * const fooOrBar2: FooOrBar = {\n *   bar: 'or this is required',\n *   qux: 'this always required',\n * };\n *\n * const fooOrBar3: FooOrBar = {\n *   foo: 'we can have foo',\n *   bar: 'and bar',\n *   qux: 'this always required',\n * };\n *\n * const fooOrBar4: FooOrBar = {\n *   // no foo nor bar\n *   qux: 'this always required',\n * }; // error TS2322: Type '{ qux: string; }' is not assignable to type 'FooOrBar'\n * ```\n *\n * @typeParam T Base for the new type\n * @typeParam P String literal or union of string literals specifying properties of `T`\n */\nexport type AtLeastOneRequired<T, P extends keyof T = keyof T> = {\n  [K in P]-?: Partial<Pick<T, Exclude<P, K>>> & Required<Pick<T, K>>;\n}[P] &\n  Pick<T, Exclude<keyof T, P>>;\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG,CACH,WAG+B"}

package/dist/types/DeepPartial.d.ts

@@ -0,0 +1,60 @@
+import type { Primitive } from './Primitive.js';
+/**
+ * Same as built-in `Partial`, but works recursively. Useful when 1) you have a config object to which you need to merge another object, which would be a deep partial of a default object, or 2) you need to test or mock complex object, but most of its keys would be redundant for this purpose.
+ *
+ * ```TypeScript
+ * import { DeepPartial } from '@ori/ts-utils';
+ * import { UiSettings } from './UiSettings';
+ *
+ * let settings: UiSettings = {
+ *   lineNumbers: true,
+ *   scrollbar: {
+ *     useShadows: false,
+ *     vertical: 'visible',
+ *     horizontal: 'auto',
+ *   },
+ *   minimap: {
+ *     enabled: false,
+ *   },
+ *   folding: {
+ *     enabled: true,
+ *   },
+ * };
+ *
+ * function updateSettings(newSettings: DeepPartial<UiSettings>) {
+ *   return { ...settings, ...newSettings };
+ * }
+ *
+ * settings = updateSettings({ minimap: { enabled: true } });
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type DeepPartial<T> = T extends Date | Primitive | RegExp ? T : T extends Map<infer KeyType, infer ValueType> ? DeepPartialMap<KeyType, ValueType> : T extends Set<infer ItemType> ? DeepPartialSet<ItemType> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? DeepPartialReadonlyMap<KeyType, ValueType> : T extends ReadonlySet<infer ItemType> ? DeepPartialReadonlySet<ItemType> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends Array<infer I> ? I[] extends T ? Array<DeepPartial<I | undefined>> : DeepPartialObject<T> : DeepPartialObject<T> : unknown;
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialMap<KeyType, ValueType> extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {
+}
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialSet<T> extends Set<DeepPartial<T>> {
+}
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialReadonlyMap<KeyType, ValueType> extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {
+}
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+interface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {
+}
+/**
+ * Helper type for {@linkcode DeepPartial}.
+ */
+declare type DeepPartialObject<ObjectType extends object> = {
+    [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;
+};
+export {};

package/dist/types/DeepPartial.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */ export { };
+
+//# sourceMappingURL=DeepPartial.js.map

package/dist/types/DeepPartial.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/DeepPartial.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */\n\nimport type {Primitive} from './Primitive.js';\n\n/**\n * Same as built-in `Partial`, but works recursively. Useful when 1) you have a config object to which you need to merge another object, which would be a deep partial of a default object, or 2) you need to test or mock complex object, but most of its keys would be redundant for this purpose.\n *\n * ```TypeScript\n * import { DeepPartial } from '@ori/ts-utils';\n * import { UiSettings } from './UiSettings';\n *\n * let settings: UiSettings = {\n *   lineNumbers: true,\n *   scrollbar: {\n *     useShadows: false,\n *     vertical: 'visible',\n *     horizontal: 'auto',\n *   },\n *   minimap: {\n *     enabled: false,\n *   },\n *   folding: {\n *     enabled: true,\n *   },\n * };\n *\n * function updateSettings(newSettings: DeepPartial<UiSettings>) {\n *   return { ...settings, ...newSettings };\n * }\n *\n * settings = updateSettings({ minimap: { enabled: true } });\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type DeepPartial<T> = T extends Date | Primitive | RegExp\n  ? T\n  : T extends Map<infer KeyType, infer ValueType>\n  ? DeepPartialMap<KeyType, ValueType>\n  : T extends Set<infer ItemType>\n  ? DeepPartialSet<ItemType>\n  : T extends ReadonlyMap<infer KeyType, infer ValueType>\n  ? DeepPartialReadonlyMap<KeyType, ValueType>\n  : T extends ReadonlySet<infer ItemType>\n  ? DeepPartialReadonlySet<ItemType>\n  : T extends (...args: any[]) => unknown\n  ? T | undefined\n  : T extends object\n  ? T extends Array<infer I> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156\n    ? I[] extends T // Test for arrays (non-tuples) specifically\n      ? Array<DeepPartial<I | undefined>> // Recreate relevant array type to prevent eager evaluation of circular reference\n      : DeepPartialObject<T> // Tuples behave properly\n    : DeepPartialObject<T>\n  : unknown;\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialMap<KeyType, ValueType>\n  extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialSet<T> extends Set<DeepPartial<T>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialReadonlyMap<KeyType, ValueType>\n  extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ntype DeepPartialObject<ObjectType extends object> = {\n  [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;\n};\n"],"names":[],"mappings":"AAAA,wGAAwG,CAExG,WAgFE"}

package/dist/types/DeepReadonly.d.ts

@@ -0,0 +1,34 @@
+import type { Primitive } from './Primitive.js';
+/**
+ * Same as built-in `Readonly`, but works recursively:
+ *
+ * ```TypeScript
+ * import { DeepReadonly } from '@ori/ts-utils';
+ *
+ * const rawData = {
+ *   foo: ['bar'],
+ * };
+ *
+ * const data: DeepReadonly<typeof rawData> = rawData;
+ *
+ * data.foo.push('bar'); // error TS2339: Property 'push' does not exist on type 'readonly string[]'
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown) ? T : T extends ReadonlyMap<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends ReadonlySet<infer I> ? DeepReadonlySet<I> : T extends object ? DeepReadonlyObject<T> : unknown;
+/**
+ * Helper type for {@linkcode DeepReadonly}.
+ */
+declare type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
+/**
+ * Helper type for {@linkcode DeepReadonly}.
+ */
+declare type DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;
+/**
+ * Helper type for {@linkcode DeepReadonly}.
+ */
+declare type DeepReadonlyObject<O extends object> = {
+    readonly [K in keyof O]: DeepReadonly<O[K]>;
+};
+export {};

package/dist/types/DeepReadonly.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ export { };
+
+//# sourceMappingURL=DeepReadonly.js.map

package/dist/types/DeepReadonly.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/DeepReadonly.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\nimport type {Primitive} from './Primitive.js';\n\n/**\n * Same as built-in `Readonly`, but works recursively:\n *\n * ```TypeScript\n * import { DeepReadonly } from '@ori/ts-utils';\n *\n * const rawData = {\n *   foo: ['bar'],\n * };\n *\n * const data: DeepReadonly<typeof rawData> = rawData;\n *\n * data.foo.push('bar'); // error TS2339: Property 'push' does not exist on type 'readonly string[]'\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown)\n  ? T\n  : T extends ReadonlyMap<infer K, infer V>\n  ? DeepReadonlyMap<K, V>\n  : T extends ReadonlySet<infer I>\n  ? DeepReadonlySet<I>\n  : T extends object\n  ? DeepReadonlyObject<T>\n  : unknown;\n\n/**\n * Helper type for {@linkcode DeepReadonly}.\n */\ntype DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;\n\n/**\n * Helper type for {@linkcode DeepReadonly}.\n */\ntype DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;\n\n/**\n * Helper type for {@linkcode DeepReadonly}.\n */\ntype DeepReadonlyObject<O extends object> = {\n  readonly [K in keyof O]: DeepReadonly<O[K]>;\n};\n"],"names":[],"mappings":"AAAA,iEAAiE,CAEjE,WA4CE"}

package/dist/types/If.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `If<X, Y, T, F>` is shorthand for conditional type `X extends Y ? T : F`:
+ *
+ * ```TypeScript
+ * // these two types are equivalent:
+ * type NonNullable<T> = T extends null | undefined ? never : T;
+ * type NonNullable<T> = If<T, null | undefined, never, T>;
+ * ```
+ *
+ * @typeParam X Type on the left of the `extends`
+ * @typeParam Y Type on the right of the `extends`
+ * @typeParam T Type returned when `X` is assignable to `Y`
+ * @typeParam F Type returned when `X` isn't assignable to `Y`
+ */
+export declare type If<X, Y, T, F> = X extends Y ? T : F;

package/dist/types/If.js

@@ -0,0 +1,16 @@
+/**
+ * `If<X, Y, T, F>` is shorthand for conditional type `X extends Y ? T : F`:
+ *
+ * ```TypeScript
+ * // these two types are equivalent:
+ * type NonNullable<T> = T extends null | undefined ? never : T;
+ * type NonNullable<T> = If<T, null | undefined, never, T>;
+ * ```
+ *
+ * @typeParam X Type on the left of the `extends`
+ * @typeParam Y Type on the right of the `extends`
+ * @typeParam T Type returned when `X` is assignable to `Y`
+ * @typeParam F Type returned when `X` isn't assignable to `Y`
+ */ export { };
+
+//# sourceMappingURL=If.js.map

package/dist/types/If.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/If.ts"],"sourcesContent":["/**\n * `If<X, Y, T, F>` is shorthand for conditional type `X extends Y ? T : F`:\n *\n * ```TypeScript\n * // these two types are equivalent:\n * type NonNullable<T> = T extends null | undefined ? never : T;\n * type NonNullable<T> = If<T, null | undefined, never, T>;\n * ```\n *\n * @typeParam X Type on the left of the `extends`\n * @typeParam Y Type on the right of the `extends`\n * @typeParam T Type returned when `X` is assignable to `Y`\n * @typeParam F Type returned when `X` isn't assignable to `Y`\n */\nexport type If<X, Y, T, F> = X extends Y ? T : F;\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG,CACH,WAAiD"}

package/dist/types/IsEqual.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Allows you to test if two types are the same:
+ *
+ * ```TypeScript
+ * type Result = IsEqual<string, number> // `typeof Result` is `false`
+ * ```
+ *
+ * ```TypeScript
+ * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`
+ * ```
+ *
+ * @typeParam A1 First type to compare
+ * @typeParam A2 Second type to compare
+ */
+export declare type IsEqual<A1, A2> = IsStrictlyEqual<Unite<A1>, Unite<A2>>;
+/**
+ * Helper type for {@linkcode IsEqual}.
+ */
+declare type IsStrictlyEqual<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
+/**
+ * Helper type for {@linkcode IsEqual}.
+ */
+declare type Unite<T> = T extends Record<string, unknown> ? {
+    [K in keyof T]: T[K];
+} : T;
+export {};

package/dist/types/IsEqual.js

@@ -0,0 +1,16 @@
+/**
+ * Allows you to test if two types are the same:
+ *
+ * ```TypeScript
+ * type Result = IsEqual<string, number> // `typeof Result` is `false`
+ * ```
+ *
+ * ```TypeScript
+ * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`
+ * ```
+ *
+ * @typeParam A1 First type to compare
+ * @typeParam A2 Second type to compare
+ */ export { };
+
+//# sourceMappingURL=IsEqual.js.map

package/dist/types/IsEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/IsEqual.ts"],"sourcesContent":["/**\n * Allows you to test if two types are the same:\n *\n * ```TypeScript\n * type Result = IsEqual<string, number> // `typeof Result` is `false`\n * ```\n *\n * ```TypeScript\n * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`\n * ```\n *\n * @typeParam A1 First type to compare\n * @typeParam A2 Second type to compare\n */\nexport type IsEqual<A1, A2> = IsStrictlyEqual<Unite<A1>, Unite<A2>>;\n\n/**\n * Helper type for {@linkcode IsEqual}.\n */\ntype IsStrictlyEqual<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1\n  ? true\n  : false\n  ? true\n  : false;\n\n/**\n * Helper type for {@linkcode IsEqual}.\n */\ntype Unite<T> = T extends Record<string, unknown> ? {[K in keyof T]: T[K]} : T;\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG,CACH,WAc+E"}

package/dist/types/LiteralUnion.d.ts

@@ -0,0 +1,21 @@
+import type { Primitive } from './Primitive.js';
+/**
+ * Creates union type by combining primitve types and literal types while allowing auto-completion in IDEs.
+ * This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
+ *
+ * ```TypeScript
+ * type Animal = 'cat' | 'dog' | string;
+ *
+ * const: animal: Animal = ''; // No auto-completion here...
+ * ```
+ *
+ * ```TypeScript
+ * type Animal = LiteralUnion<'cat' | 'dog', string>;
+ *
+ * const: animal: Animal = ''; // Auto-completion works: 'cat' and 'dog' is suggested!
+ * ```
+ *
+ * @typeParam L Union of literal types
+ * @typeParam T Primitive type
+ */
+export declare type LiteralUnion<L, T extends Primitive> = L | (Record<never, never> & T);

package/dist/types/LiteralUnion.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=LiteralUnion.js.map

package/dist/types/LiteralUnion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/LiteralUnion.ts"],"sourcesContent":["import type {Primitive} from './Primitive.js';\n\n/**\n * Creates union type by combining primitve types and literal types while allowing auto-completion in IDEs.\n * This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).\n *\n * ```TypeScript\n * type Animal = 'cat' | 'dog' | string;\n *\n * const: animal: Animal = ''; // No auto-completion here...\n * ```\n *\n * ```TypeScript\n * type Animal = LiteralUnion<'cat' | 'dog', string>;\n *\n * const: animal: Animal = ''; // Auto-completion works: 'cat' and 'dog' is suggested!\n * ```\n *\n * @typeParam L Union of literal types\n * @typeParam T Primitive type\n */\nexport type LiteralUnion<L, T extends Primitive> = L | (Record<never, never> & T);\n"],"names":[],"mappings":"AAAA,WAqBkF"}

package/dist/types/NonArray.d.ts

@@ -0,0 +1 @@
+export declare type NonArray<T> = T extends any[] ? never : T;

package/dist/types/NonArray.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ export { };
+
+//# sourceMappingURL=NonArray.js.map

package/dist/types/NonArray.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/NonArray.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\nexport type NonArray<T> = T extends any[] ? never : T;\n"],"names":[],"mappings":"AAAA,iEAAiE,CAEjE,WAAsD"}

package/dist/types/NonArrayLike.d.ts

@@ -0,0 +1 @@
+export declare type NonArrayLike<T> = T extends ArrayLike<any> ? never : T;

package/dist/types/NonArrayLike.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ export { };
+
+//# sourceMappingURL=NonArrayLike.js.map

package/dist/types/NonArrayLike.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/NonArrayLike.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\nexport type NonArrayLike<T> = T extends ArrayLike<any> ? never : T;\n"],"names":[],"mappings":"AAAA,iEAAiE,CAEjE,WAAmE"}

package/dist/types/OptionalKeys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extracts the optional keys of type `T`:
+ *
+ * ```TypeScript
+ * type Result = OptionalKeys<{ foo?: number; bar?: string; baz: boolean; }>; // `typeof Result` is `'foo' | 'bar`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type OptionalKeys<T extends object> = Exclude<{
+    [K in keyof T]: T extends Record<K, T[K]> ? never : K;
+}[keyof T], undefined>;

package/dist/types/OptionalKeys.js

@@ -0,0 +1,11 @@
+/**
+ * Extracts the optional keys of type `T`:
+ *
+ * ```TypeScript
+ * type Result = OptionalKeys<{ foo?: number; bar?: string; baz: boolean; }>; // `typeof Result` is `'foo' | 'bar`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
+
+//# sourceMappingURL=OptionalKeys.js.map

package/dist/types/OptionalKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/OptionalKeys.ts"],"sourcesContent":["/**\n * Extracts the optional keys of type `T`:\n *\n * ```TypeScript\n * type Result = OptionalKeys<{ foo?: number; bar?: string; baz: boolean; }>; // `typeof Result` is `'foo' | 'bar`\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type OptionalKeys<T extends object> = Exclude<\n  {\n    [K in keyof T]: T extends Record<K, T[K]> ? never : K;\n  }[keyof T],\n  undefined\n>;\n"],"names":[],"mappings":"AAAA;;;;;;;;GAQG,CACH,WAKE"}

package/dist/types/Parameters.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Constructs a tuple type from the types used in the parameters of a function type `T`.
+ * Similarly like built-in `Parameters` utility type, but works also on nullable and other types.
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   get?: (id: number) => string;
+ * }
+ *
+ * declare const foo: Foo;
+ *
+ * type Result = Parameters<typeof foo.get>; // `typeof Result` is `[id: number]`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type Parameters<T extends '' | false | ((...args: any[]) => any) | null | undefined> = T extends (...args: infer P) => any ? P : never;

package/dist/types/Parameters.js

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ /**
+ * Constructs a tuple type from the types used in the parameters of a function type `T`.
+ * Similarly like built-in `Parameters` utility type, but works also on nullable and other types.
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   get?: (id: number) => string;
+ * }
+ *
+ * declare const foo: Foo;
+ *
+ * type Result = Parameters<typeof foo.get>; // `typeof Result` is `[id: number]`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
+
+//# sourceMappingURL=Parameters.js.map

package/dist/types/Parameters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/Parameters.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\n/**\n * Constructs a tuple type from the types used in the parameters of a function type `T`.\n * Similarly like built-in `Parameters` utility type, but works also on nullable and other types.\n *\n * ```TypeScript\n * interface Foo {\n *   get?: (id: number) => string;\n * }\n *\n * declare const foo: Foo;\n *\n * type Result = Parameters<typeof foo.get>; // `typeof Result` is `[id: number]`\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type Parameters<T extends '' | false | ((...args: any[]) => any) | null | undefined> =\n  T extends (...args: infer P) => any ? P : never;\n"],"names":[],"mappings":"AAAA,iEAAiE,CAEjE;;;;;;;;;;;;;;;GAeG,CACH,WACkD"}

package/dist/types/Primitive.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Union of primitive types.
+ */
+export declare type Primitive = bigint | boolean | number | string | symbol | null | undefined;

package/dist/types/Primitive.js

@@ -0,0 +1,5 @@
+/**
+ * Union of primitive types.
+ */ export { };
+
+//# sourceMappingURL=Primitive.js.map

package/dist/types/Primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/Primitive.ts"],"sourcesContent":["/**\n * Union of primitive types.\n */\nexport type Primitive = bigint | boolean | number | string | symbol | null | undefined;\n"],"names":[],"mappings":"AAAA;;GAEG,CACH,WAAuF"}

package/dist/types/RequiredKeys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extracts the non-optional keys of type `T`:
+ *
+ * ```TypeScript
+ * type Result = RequiredKeys<{ foo: number; bar: string; baz?: boolean; }>; // `typeof Result` is `'foo' | 'bar`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type RequiredKeys<T extends object> = Exclude<{
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+}[keyof T], undefined>;

package/dist/types/RequiredKeys.js

@@ -0,0 +1,11 @@
+/**
+ * Extracts the non-optional keys of type `T`:
+ *
+ * ```TypeScript
+ * type Result = RequiredKeys<{ foo: number; bar: string; baz?: boolean; }>; // `typeof Result` is `'foo' | 'bar`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
+
+//# sourceMappingURL=RequiredKeys.js.map

package/dist/types/RequiredKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/RequiredKeys.ts"],"sourcesContent":["/**\n * Extracts the non-optional keys of type `T`:\n *\n * ```TypeScript\n * type Result = RequiredKeys<{ foo: number; bar: string; baz?: boolean; }>; // `typeof Result` is `'foo' | 'bar`\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type RequiredKeys<T extends object> = Exclude<\n  {\n    [K in keyof T]: T extends Record<K, T[K]> ? K : never;\n  }[keyof T],\n  undefined\n>;\n"],"names":[],"mappings":"AAAA;;;;;;;;GAQG,CACH,WAKE"}

package/dist/types/ReturnType.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Constructs a type consisting of the return type of function `T`.
+ * Similarly like built-in `ReturnType` utility type, but works also on nullable and other types,
+ * and if you use it with async function, it doesn't return the type as a `Promise`:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   get?: (id: number) => Promise<string>;
+ * }
+ *
+ * declare const foo: Foo;
+ *
+ * type Result = ReturnType<typeof foo.get>; // `typeof Result` is `string`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type ReturnType<T extends '' | false | ((...args: any[]) => any) | null | undefined> = T extends (...args: any[]) => infer R ? (R extends PromiseLike<infer J> ? J : R) : never;

package/dist/types/ReturnType.js

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ /**
+ * Constructs a type consisting of the return type of function `T`.
+ * Similarly like built-in `ReturnType` utility type, but works also on nullable and other types,
+ * and if you use it with async function, it doesn't return the type as a `Promise`:
+ *
+ * ```TypeScript
+ * interface Foo {
+ *   get?: (id: number) => Promise<string>;
+ * }
+ *
+ * declare const foo: Foo;
+ *
+ * type Result = ReturnType<typeof foo.get>; // `typeof Result` is `string`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
+
+//# sourceMappingURL=ReturnType.js.map

package/dist/types/ReturnType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/ReturnType.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\n/**\n * Constructs a type consisting of the return type of function `T`.\n * Similarly like built-in `ReturnType` utility type, but works also on nullable and other types,\n * and if you use it with async function, it doesn't return the type as a `Promise`:\n *\n * ```TypeScript\n * interface Foo {\n *   get?: (id: number) => Promise<string>;\n * }\n *\n * declare const foo: Foo;\n *\n * type Result = ReturnType<typeof foo.get>; // `typeof Result` is `string`\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type ReturnType<T extends '' | false | ((...args: any[]) => any) | null | undefined> =\n  T extends (...args: any[]) => infer R ? (R extends PromiseLike<infer J> ? J : R) : never;\n"],"names":[],"mappings":"AAAA,iEAAiE,CAEjE;;;;;;;;;;;;;;;;GAgBG,CACH,WAC2F"}

package/dist/types/TupleToUnion.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts tuple type to union type:
+ *
+ * ```TypeScript
+ * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `"foo" | "bar"`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */
+export declare type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];

package/dist/types/TupleToUnion.js

@@ -0,0 +1,11 @@
+/**
+ * Converts tuple type to union type:
+ *
+ * ```TypeScript
+ * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `"foo" | "bar"`
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
+
+//# sourceMappingURL=TupleToUnion.js.map

package/dist/types/TupleToUnion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/TupleToUnion.ts"],"sourcesContent":["/**\n * Converts tuple type to union type:\n *\n * ```TypeScript\n * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `\"foo\" | \"bar\"`\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];\n"],"names":[],"mappings":"AAAA;;;;;;;;GAQG,CACH,WAA+E"}

package/dist/types/UnionToIntersection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Converts union type to intersection type:
+ *
+ * ```TypeScript
+ * type Result = UnionToIntersection<{ foo: string } | { bar: string }>; // `typeof Result` is `{foo: string} & {bar: string}`
+ * ```
+ *
+ * @typeParam U Base for the new type
+ */
+export declare type UnionToIntersection<U> = boolean extends U ? UnionToIntersectionHelper<Exclude<U, boolean>> & boolean : UnionToIntersectionHelper<U>;
+/**
+ * Helper type for {@linkcode UnionToIntersection}.
+ */
+declare type UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export {};

package/dist/types/UnionToIntersection.js

@@ -0,0 +1,11 @@
+/**
+ * Converts union type to intersection type:
+ *
+ * ```TypeScript
+ * type Result = UnionToIntersection<{ foo: string } | { bar: string }>; // `typeof Result` is `{foo: string} & {bar: string}`
+ * ```
+ *
+ * @typeParam U Base for the new type
+ */ export { };
+
+//# sourceMappingURL=UnionToIntersection.js.map

package/dist/types/UnionToIntersection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/UnionToIntersection.ts"],"sourcesContent":["/**\n * Converts union type to intersection type:\n *\n * ```TypeScript\n * type Result = UnionToIntersection<{ foo: string } | { bar: string }>; // `typeof Result` is `{foo: string} & {bar: string}`\n * ```\n *\n * @typeParam U Base for the new type\n */\nexport type UnionToIntersection<U> = boolean extends U\n  ? UnionToIntersectionHelper<Exclude<U, boolean>> & boolean\n  : UnionToIntersectionHelper<U>;\n\n/**\n * Helper type for {@linkcode UnionToIntersection}.\n */\ntype UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n"],"names":[],"mappings":"AAAA;;;;;;;;GAQG,CACH,WAWU"}

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+export * from './types/AtLeastOneRequired.js';
+export * from './types/DeepPartial.js';
+export * from './types/DeepReadonly.js';
+export * from './types/If.js';
+export * from './types/IsEqual.js';
+export * from './types/LiteralUnion.js';
+export * from './types/NonArray.js';
+export * from './types/NonArrayLike.js';
+export * from './types/OptionalKeys.js';
+export * from './types/Parameters.js';
+export * from './types/Primitive.js';
+export * from './types/RequiredKeys.js';
+export * from './types/ReturnType.js';
+export * from './types/TupleToUnion.js';
+export * from './types/UnionToIntersection.js';