inferred-types 0.51.1 → 0.51.2

package/src/types/boolean-logic/operators/HasRequiredProps.ts

@@ -1,17 +0,0 @@
-import { Keys, Dictionary, ObjectKey, RequiredProps } from "inferred-types/dist/types/index";
-
-/**
- * **HasRequiredProps**`<T>`
- *
- * Receives an object and returns true/false based on whether
- * the type has required properties or not.
- */
-export type HasRequiredProps<
-  T extends object
-> = T extends Dictionary
-? Keys<RequiredProps<T>> extends readonly ObjectKey[]
-  ? Keys<RequiredProps<T>>["length"] extends 0
-    ? false
-    : true
-  : false
-: false;

package/src/types/boolean-logic/operators/HasSameKeys.ts

@@ -1,41 +0,0 @@
-import {  And,  AsTuple, Container, DoesExtend,   HasSameValues,   IsTuple, ObjectKey,RemoveIndexKeys,  UnionToTuple } from "inferred-types/dist/types/index"
-
-
-
-type Process<
-  A extends readonly unknown[],
-  B extends readonly unknown[],
-> = And<{
-  [K in keyof A]: K extends keyof B
-    ? true
-    : false
-}>
-
-type _Keys<T extends object> = UnionToTuple<keyof RemoveIndexKeys<T>> extends readonly ObjectKey[]
-? UnionToTuple<keyof RemoveIndexKeys<T>>
-: never
-
-
-
-/**
- * **HasSameKeys**`<A,B>`
- *
- * Boolean operator which compares two lists to see if they have the same keys.
- */
-export type HasSameKeys<
-  A extends Container,
-  B extends Container
-> =
-IsTuple<A> extends true
-  ? IsTuple<B> extends true
-    ? AsTuple<A>["length"] extends AsTuple<B>["length"]
-      ? Process<AsTuple<A>,AsTuple<B>>
-      : false
-  : false
-: DoesExtend<A,object> extends true
-  ? DoesExtend<B,object> extends true
-    ? _Keys<A>["length"] extends _Keys<B>["length"]
-      ? HasSameValues< _Keys<A>, _Keys<B>>
-      : false
-    : false
-  : false;

package/src/types/boolean-logic/operators/HasSameValues.ts

@@ -1,53 +0,0 @@
-import { And, Dictionary, If, IsNever, Or, Values } from "inferred-types/dist/types/index";
-
-type Find<
-  TList extends readonly unknown[],
-  TComparator
-> = Or<{
-  [K in keyof TList]: [TList[K]] extends [TComparator] ? true : false
-}>;
-
-type Compare<
-  TList extends readonly unknown[],
-  TComparator extends readonly unknown[]
-> = And<{
-  [K in keyof TList]: Find<TComparator, TList[K]> extends boolean
-    ? Find<TComparator, TList[K]>
-    : never
-}, true>
-
-type Process<
-TList extends readonly unknown[],
-TComparator extends readonly unknown[]
-> = TList["length"] extends TComparator["length"]
-? Compare<
-  TList,
-  TComparator
->
-: false;
-
-
-type _HasSameValues<
-TContainer extends readonly unknown[],
-TComparator extends readonly unknown[]
-> = TContainer extends readonly unknown[]
-? Process<TContainer,TComparator>
-: TContainer extends Dictionary
-? Process<Values<TContainer>,TComparator>
-: never;
-
-/**
- * **HasSameValues**`<TContainer,TComparator>`
- *
- * Boolean type utility which determines if the values in
- * `TList` and `TComparator` are the same (even if the order
- * is different).
- */
-export type HasSameValues<
-  TContainer extends readonly unknown[],
-  TComparator extends readonly unknown[]
-> = If<
-  IsNever<TContainer>,
-  If<IsNever<TComparator>, true, false>,
-  If<IsNever<TComparator>, false, _HasSameValues<TContainer,TComparator>>
->

package/src/types/boolean-logic/operators/HasUnionType.ts

@@ -1,16 +0,0 @@
-import { AfterFirst, First,  IsUnion } from "inferred-types/dist/types/index";
-
-type _HasUnion<
-  TList extends readonly unknown[]
-> = [] extends TList
-  ? false
-  : IsUnion<First<TList>> extends true
-      ? true
-      : _HasUnion<AfterFirst<TList>>;
-
-/**
- * **HasUnionType**`<TList>`
- *
- * Checks whether a list of items includes a value in it which is a _union type_.
- */
-export type HasUnionType<TList extends readonly unknown[]> = _HasUnion<TList>;

package/src/types/boolean-logic/operators/HasWideValues.ts

@@ -1,14 +0,0 @@
-import { AfterFirst, First, IsWideType } from "inferred-types/dist/types/index";
-
-type Validate<T extends readonly unknown[]> = [] extends T
-? false
-: IsWideType<First<T>> extends true
-  ? true
-  : Validate<AfterFirst<T>>;
-
-/**
- * **HasWideValues**`<T>`
- *
- * Tests whether any values in the tuple are _wide_ (aka, not a literal) value.
- */
-export type HasWideValues<T extends readonly unknown[]> = Validate<T>;

package/src/types/boolean-logic/operators/HaveSameNumericSign.ts

@@ -1,24 +0,0 @@
-
-import {
-  If,
-  NumberLike,
-  IsNegativeNumber,
-  IsPositiveNumber
-} from "inferred-types/dist/types/index";
-
-/**
- * **HaveSameNumericSign**`<A,B>`
- *
- * Validates that `A` _and_ `B` are both negative number or both
- * positive numbers.
- */
-export type HaveSameNumericSign<
-  A extends NumberLike,
-  B extends NumberLike
-> = If<
-  IsPositiveNumber<A>,
-  IsPositiveNumber<B> extends true ? true : false,
-  IsNegativeNumber<B> extends true ? true : false
->
-
-

package/src/types/boolean-logic/operators/IsAllCaps.ts

@@ -1,23 +0,0 @@
-
-/**
- * **IsAllCaps**`<T>
- * 
- * Boolean operator which returns _true_ when `T` consists of ALL capital letters.
- * 
- * - Note: non-alphabetic characters are ignored by this utility
- * 
- * ```ts
- * // true
- * type T = AllCaps<"FOOBAR">;
- * type T2 = AllCaps<"FOOBAR2">;
- * // false 
- * type T = AllCaps<"FooBar">;
- * // boolean
- * type T = AllCaps<string>;
- * ```
- * 
- * **Related:** `IsAllLowercase`
- */
-export type IsAllCaps<T extends string> = string extends T
-  ? boolean
-  : T extends Uppercase<T> ? true : false;

package/src/types/boolean-logic/operators/IsAllLowercase.ts

@@ -1,22 +0,0 @@
-import { UpperAlphaChar, If,HasCharacters } from "inferred-types/dist/types/index";
-
-/**
- * **IsAllLowercase**`<T>`
- *
- * Boolean operator which indicates whether `T` has _all_ lowercase characters in it.
- * Valid values are:
- *
- * - note: any non-alphabetic characters are ignored in the evaluation
- *
- * ```ts
- * // true
- * type T = AllCaps<"foobar">;
- * // false
- * type T = AllCaps<"FooBar">;
- * // boolean
- * type T = AllCaps<string>;
- * ```
- */
-export type IsAllLowercase<T extends string> = string extends T
-  ? boolean
-  : If<HasCharacters<T, UpperAlphaChar>, true, false>;

package/src/types/boolean-logic/operators/IsAny.ts

@@ -1,10 +0,0 @@
-import { IsNever } from "inferred-types/dist/types/index";
-
-/**
- * **IsAny**`<T>`
- *
- * Tests whether a given `T` is of the **any** type.
- */
-export type IsAny<T> = IsNever<T> extends true
-? false
-: 1 extends T & 0 ? true : false;

package/src/types/boolean-logic/operators/IsAnyEqual.ts

@@ -1,14 +0,0 @@
-import { AfterFirst, First, IsEqual } from "inferred-types/dist/types/index";
-
-/**
- * **IsAnyEqual**`<TVal,TList>`
- *
- * Boolean tester which reports on whether `TVal` equals **any** of
- * the values in `TList`.
- */
-export type IsAnyEqual<TVal, TList extends readonly unknown[]> = //
-  [] extends TList
-    ? true
-    : IsEqual<TVal,First<TList>> extends true
-      ? IsAnyEqual<TVal, readonly [...AfterFirst<TList>]>
-      : false;

package/src/types/boolean-logic/operators/IsArray.ts

@@ -1,12 +0,0 @@
- 
-/**
- * **IsArray**
- * 
- * Boolean utility which tests for whether `T` is an array (
- * both a mutable array or a readonly array)
- */
-export type IsArray<T> = [T] extends [any[]] 
-  ? true 
-  : [T] extends [readonly any[]] 
-    ? true 
-    : false;

package/src/types/boolean-logic/operators/IsBoolean.ts

@@ -1,13 +0,0 @@
-import {  WidenUnion, IsUnion } from "inferred-types/dist/types/index";
-/**
- * **IsBoolean**
- *
- * Boolean type utility which detects literal or wide boolean type.
- */
-export type IsBoolean<T> = [IsUnion<T>] extends [true]
-? [WidenUnion<T>] extends [boolean]
-  ? true
-  : [string] extends [WidenUnion<T>]
-    ? boolean
-    : false
-: [T] extends [boolean] ? true : false;

package/src/types/boolean-logic/operators/IsBooleanLiteral.ts

@@ -1,20 +0,0 @@
-import type {   IsFalse, IsNever, IsTrue } from "inferred-types/dist/types/index";
-
-// [note on handling of boolean](https://stackoverflow.com/questions/74213646/detecting-type-literals-works-in-isolation-but-not-when-combined-with-other-lite/74213713#74213713)
-
-/**
- * **IsBooleanLiteral**`<T>`
- *
- * Boolean type utility which detects whether `T`
- * is a boolean literal (aka, is `true` or `false`)
- */
-export type IsBooleanLiteral<
-  T
-> = [IsNever<T>] extends [true]
-  ? false
-  : [IsTrue<T>] extends [true]
-    ? true
-    : [IsFalse<T>] extends [true]
-    ? true
-    : false;
-

package/src/types/boolean-logic/operators/IsContainer.ts

@@ -1,16 +0,0 @@
-
-import type {  IsNever, Dictionary } from "inferred-types/dist/types/index";
-
-/**
- * **IsContainer**`<T>`
- *
- * Boolean operator which detects whether `T` is a "container" where a
- * container is any object or array.
- */
-export type IsContainer<T> = IsNever<T> extends true
-? false
-: [T] extends [Dictionary]
-  ? true
-  : [T] extends [readonly any[]]
-    ? true
-    : false;

package/src/types/boolean-logic/operators/IsCssHexadecimal.ts

@@ -1,15 +0,0 @@
-import { IsHexadecimal, IsStringLiteral } from "inferred-types/dist/types/index"
-
-/**
- * **IsHexadecimal**`<T>`
- *
- * Ensures that `T` is a valid hexadecimal and converts to **never**
- * otherwise.
- */
-export type IsCssHexadecimal<T> = T extends string
-? IsStringLiteral<T> extends true
-  ? T extends `#${infer Rest}`
-    ? IsHexadecimal<Rest>
-    : false
-  : boolean
-: false;

package/src/types/boolean-logic/operators/IsDefined.ts

@@ -1,6 +0,0 @@
-/**
- * **IsDefined**
- *
- * Boolean type utility returns `true` if `T` is defined; `false` if undefined
- */
-export type IsDefined<T> = T extends undefined ? false : true;

package/src/types/boolean-logic/operators/IsDotPath.ts

@@ -1,55 +0,0 @@
-import {
-  HasCharacters,
-  IsNever,
-  StartsWith,
-  IsStringLiteral,
-  EndsWith,
-  Contains,
-  IsEqual
-} from "inferred-types/dist/types/index";
-
-type CheckForInvalid<
-  T extends string
-> = HasCharacters<T, ["/", "*", "!", "&", "$", "\\"]> extends true
-? true
-: StartsWith<T,"."> extends true
-? true
-: EndsWith<T,"."> extends true
-? true
-: Contains<T,".."> extends true
-? true
-: false;
-
-/**
- * **IsDotPath**`<T>`
- *
- * Boolean operator which detects whether a given `T` should be considered a
- * "dot path". Results based on `T` are:
- *
- * - `false` - any non-string type or any string literal in which `DotPath<T>` resolves
- * to false (including _never_ value).
- * - `boolean` - a wide string type
- * - `true` - a string literal value where `DotPath<T>` does not resolve to _never_.
- *
- * Note: this utility does not validate that `T` is a _valid_ dot path for a particular
- * container; only that it is a valid looking dotpath. If you want this validation use
- * `IsValidDotPath<TContainer, TKey>` instead.
- */
-export type IsDotPath<
-  T,
-  TIf = true,
-  TElse = false,
-  TMaybe = TIf | TElse
-> = [IsNever<T>] extends [true]
-  ? false
-  : T extends string
-    ? [IsEqual<T, ""> ] extends [true]
-      ? true
-      : IsStringLiteral<T> extends true
-        ? CheckForInvalid<T> extends true
-          ? TElse
-          : TIf
-        : TMaybe
-: false
-
-

package/src/types/boolean-logic/operators/IsEmptyObject.ts

@@ -1,19 +0,0 @@
-import type {AsRecord,  Dictionary,  IsNumericLiteral,  Keys} from "inferred-types/dist/types/index";
-
-/**
- * **IsEmptyObject**`<T>`
- *
- * Boolean type util which detects whether `T` _is_ an object
- * but _has no properties_.
- */
-export type IsEmptyObject<T> = T extends Dictionary
-  ? Keys<AsRecord<T>>["length"] extends 0 ? true : false
-  : false;
-
-export type IsNonEmptyObject<T> = T extends Dictionary
-  ? Keys<AsRecord<T>>["length"] extends 0
-    ? false
-    : IsNumericLiteral<Keys<AsRecord<T>>["length"]> extends true
-      ? true
-      : false
-  : false;

package/src/types/boolean-logic/operators/IsEmptyString.ts

@@ -1,18 +0,0 @@
-import { IsEqual } from "./IsEqual";
-import { IsStringLiteral } from "./IsStringLiteral";
-
-/**
- * **IsEmptyString**`<T>`
- *
- * Returns:
- * - `true` when string T is a literal _and_ equal to ""
- * - `boolean` when string T is wide
- * - `false` for all other conditions
- */
-export type IsEmptyString<T> = T extends string
-? IsStringLiteral<T> extends true
-  ? IsEqual<T, ""> extends true
-    ? true
-    : false
-: boolean
-: false;

package/src/types/boolean-logic/operators/IsEqual.ts

@@ -1,23 +0,0 @@
-
-
-/**
- * **IsEqual**`<X,Y>`
- *
- * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
- */
-export type IsEqual<
-  X,
-  Y,
-  TRUE = true,
-  FALSE = false
-> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-  ? TRUE
-  : FALSE;
-
-/**
- * **Equals**`<X,Y>`
- *
- * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
- */
-export type Equals<X,Y,TTrue = true,TFalse = false> = IsEqual<X,Y,TTrue,TFalse>;
-

package/src/types/boolean-logic/operators/IsErrorCondition.ts

@@ -1,19 +0,0 @@
-import type { ErrorCondition } from "inferred-types/dist/types/index";
-
-/**
- * **IsErrorCondition**`<TEval,[TKind]>`
- *
- * Type utility which checks whether `TEval` is an `ErrorCondition` type.
- *
- * - If you want to isolate to only a particular _kind_ of error you may
- * also use the optional `TKind` generic.
- */
-export type IsErrorCondition<
-  TEval,
-  TKind extends string | null = null,
-> = TEval extends ErrorCondition
-  ? TKind extends string
-    ? TEval extends ErrorCondition<TKind>
-      ? true : false
-    : true
-  : false;

package/src/types/boolean-logic/operators/IsFalse.ts

@@ -1,22 +0,0 @@
-import { IsBoolean, IsNever } from "inferred-types/dist/types/index";
-
-
-/**
- * **IsFalse**`<T>`
- *
- * Type utility which checks for the narrow type of `false`
- * ```ts
- * // true
- * type T = IsFalse<true>;
- * // false
- * type U = IsFalse<boolean>;
- * type F2 = IsFalse<"foobar">;
- * ```
- */
-export type IsFalse<T> = IsNever<T> extends true
-  ? never
-  : IsBoolean<T> extends true
-  ? T extends false
-    ? true
-    : false
-  : false;

package/src/types/boolean-logic/operators/IsFalsy.ts

@@ -1,13 +0,0 @@
-import { If, ExtendsSome } from "inferred-types/dist/types/index";
-
-/**
- * **IsFalsy**`<T>`
- *
- * Boolean operator which tests whether `T` is _falsy_.
- */
-export type IsFalsy<T> = If<
-  ExtendsSome<T, ["", false, null, undefined, 0, -0, typeof Number.NaN]>,
-  true,
-  false
->;
-

package/src/types/boolean-logic/operators/IsFloat.ts

@@ -1,24 +0,0 @@
-import { HasCharacters, IsNever, IsStringLiteral, NumberLike } from "inferred-types/dist/types/index";
-
-
-/**
- * **IsFloat**`<T>`
- *
- * Boolean operator which tests whether `T` is a **float** representation of
- * a `NumberLike` type `T`.
- *
- * **Warning:** when using numeric values like `1.0` the `.0` portion is lost before
- * making the comparison so it is not possible to mark this as a float value.
- * However, the string literal version of `"1.0"` **is** marked as a float.
- */
-export type IsFloat<T> = [IsNever<T>] extends [true]
-? false
-: [T] extends [NumberLike]
-  ? [IsStringLiteral<`${T}`>] extends [true]
-    ? [HasCharacters<`${T}`, ".">] extends [true]
-      ? true
-      : false
-  : boolean
-: false;
-
-

package/src/types/boolean-logic/operators/IsFnWithParams.ts

@@ -1,37 +0,0 @@
-import type {
-  AnyObject,
-  AnyFunction ,
-  IsEmptyObject,
-  IsEqual,
-  And,
-  DoesExtend,
-  If
-} from "inferred-types/dist/types/index";
-
-/**
- * **IsFnWithParams**`<TFn, [TParamMatch]>`
- *
- * Checks whether `T` is a function which also includes
- * dictionary props sitting alongside the function.
- *
- * - the optional `TParamMatch` will ensure that this generic _extends_
- * the params included in the function.
- */
-export type IsFnWithParams<
-  TFn,
-  TParamMatch extends AnyObject | undefined = undefined
-> = TFn extends AnyFunction
-    ? IsEmptyObject<TFn> extends true
-        ? false
-        : // there are some props on TFn
-          If<
-            And<[
-              // the Fn extends the param matcher
-              DoesExtend<TFn, TParamMatch>,
-              // TParamMatch is set
-              DoesExtend<TParamMatch, AnyObject>,
-            ]>,
-            true,
-            If<IsEqual<TParamMatch, undefined>, true, false>
-        >
-    : false;

package/src/types/boolean-logic/operators/IsFunction.ts

@@ -1,10 +0,0 @@
-import type {  AnyFunction } from "inferred-types/dist/types/index";
-
-
-/**
- * **IsFunction**`<T>`
- *
- * Checks whether `T` is a function of _any_ kind and that includes
- * functions with dictionary props sitting alongside the function.
- */
-export type IsFunction<T> = T extends AnyFunction ? true : false;

package/src/types/boolean-logic/operators/IsGreaterThan.ts

@@ -1,43 +0,0 @@
-import { AsNumber, If, IsEqual, NumberLike, Or } from "inferred-types/dist/types/index";
-
-type Calc<
-  A extends number,
-  B extends number,
-  Count extends 1[] = []
-> =
-Count["length"] extends A
-  ? false
-  : Count["length"] extends B
-    ? true
-    : Calc<A,B, [...Count, 1]>;
-
-/**
- * **IsGreaterThan**`<A,B>`
- *
- * Boolean type operator which determines whether `A`
- * is _greater than_ `B`.
- *
- * **Note:** does not take negative numbers into account
- */
-export type IsGreaterThan<
-  A extends NumberLike,
-  B extends NumberLike
-> = If<
-  Or<[IsEqual<A,number>, IsEqual<B,number>, IsEqual<A,`${number}`>, IsEqual<B,`${number}`>]>,
-  boolean,
-  Calc<AsNumber<A>, AsNumber<B>>
->;
-
-
-
-/**
- * **IsGreaterThanOrEqual**`<A,B>`
- *
- * Test whether `A` is _greater than_ or _equal_ to `B`.
- */
-export type IsGreaterThanOrEqual<
-  A extends NumberLike,
-  B extends NumberLike
-> = IsEqual<A,B> extends true
-? true
-: IsGreaterThan<A,B>;

package/src/types/boolean-logic/operators/IsInteger.ts

@@ -1,18 +0,0 @@
-import { HasCharacters, IsNever, IsStringLiteral, NumberLike } from "inferred-types/dist/types/index";
-
-
-/**
- * **IsInteger**`<T>`
- *
- * Boolean operator which tests whether `T` is a **integer** representation of
- * a `NumberLike` type `T`.
- */
-export type IsInteger<T> = [IsNever<T>] extends [true]
-? false
-: [T] extends [NumberLike]
-  ? [IsStringLiteral<`${T}`>] extends [true]
-    ? [HasCharacters<`${T}`, ".">] extends [true]
-      ? false
-      : true
-  : boolean
-: false;