inferred-types 0.51.1 → 0.51.2

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

@@ -1,35 +0,0 @@
-
-import { Container, Contains, IsNever, Dictionary, Keys } from "inferred-types/dist/types/index";
-
-type Process<T extends Container> = T extends Generator
-  ? true
-  : T extends Map<any, any>
-  ? true
-  : T extends WeakMap<any, any>
-  ? true
-  : T extends Set<any>
-  ? true
-  : T extends readonly any[]
-  ? true
-  : T extends Dictionary
-  ? Contains<Keys<T>, Iterator<T>> extends true
-    ? true
-    : false
-  : false;
-
-
-/**
- * **IsIterable**`<T>`
- *
- * Boolean operator which tests whether `T` is iterable.
- */
-export type IsIterable<
-  T,
-  TNever = never
-> = IsNever<T> extends true
-? TNever
-: T extends Container
-  ? Process<T>
-  : false;
-
-

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

@@ -1,14 +0,0 @@
-import type { Length , IfEqual } from "inferred-types/dist/types/index";
-
-/**
- * **IsLength**`<T, LEN>`
- *
- * Boolean type utility which returns true/false based on whether
- * the correct length for `T` is specified.
- */
-export type IsLength<
-  T,
-  LEN extends number
-> = T extends readonly unknown[]
-  ? IfEqual<Length<T>, LEN, true, false>
-  : false;

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

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

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

@@ -1,48 +0,0 @@
-import type {
- IsStringLiteral,
- IsNumericLiteral,
- IsTuple,
- IsBooleanLiteral,
- IsObjectLiteral,
- IfEqual,
- IsUnion,
-} from "inferred-types/dist/types/index";
-
-type Validations<T> = IsStringLiteral<T> extends true
-? true
-: IsNumericLiteral<T> extends true
-? true
-: IsTuple<T> extends true
-? true
-: IsBooleanLiteral<T> extends true
-? true
-: IsObjectLiteral<T> extends true
-? true
-: false;
-
-/**
- * **IsLiteral**`<T>`
- *
- * Boolean utility which returns `true` when `T` is:
- *
- * - string literal
- * - numeric literal
- * - boolean literal
- * - object literal
- * - or a tuple literal
- *
- * Note: when `T` is a _union type_, even if there are literal types
- * in the union, this will return `false`.
- *
- * **Related:** `IsUnion`, `IsWideUnion`, `IsLiteralUnion`
- */
-export type IsLiteral<T> = [IsUnion<T>] extends [true]
-? false
-: Validations<T>
-
-
-
-//TODO: for reasons unknown we can't add in the `IsObjectLiteral<T>` test!
-
-export type IsOptionalLiteral<T> = IfEqual<T, undefined, true, IsLiteral<T>>
-

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

@@ -1,24 +0,0 @@
-
-
-import { AnyFunction } from "inferred-types/dist/types/index";
-import { IsEqual } from "./IsEqual";
-
-
-type RegularFn<Fn> = Fn extends ((...args: any[]) => any)
-? (...args: Parameters<Fn>) => ReturnType<Fn>
-: false;
-
-
-/**
- * **IsLiteralFn**`<TFn>`
- *
- * A boolean operator which checks that `TFn`:
- *
- * - is a function
- * - does not use generics to narrow input parameters
- *
- * **Related:** `LiteralFn`, `IsNarrowFn`
- */
-export type IsLiteralFn<TFn> = TFn extends AnyFunction
-? IsEqual<RegularFn<TFn>,TFn>
-: false;

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

@@ -1,21 +0,0 @@
-import {  IsUnion, RetainLiterals,  UnionToTuple } from "inferred-types/dist/types/index";
-
-
-type Process<T> = UnionToTuple<T> extends readonly unknown[]
-? RetainLiterals<UnionToTuple<T>>["length"] extends UnionToTuple<T>["length"]
-  ? true
-  : false
-: never;
-
-/**
- * **IsLiteralUnion**`<T>`
- *
- * Boolean utility which checks whether `T` is both a _union type_
- * and that it's elements are all considered _literal type_.
- *
- * **Related:** `IsLiteralUnion`, `IsWideUnion`
- */
-export type IsLiteralUnion<
-  T> = [IsUnion<T>] extends [true]
-  ? Process<T>
-  : false;

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

@@ -1,19 +0,0 @@
-import { AnyFunction, Not, IsEqual, LiteralFn } from "inferred-types/dist/types/index";
-
-
-
-
-/**
- * **IsNarrowingFn**`<TFn>`
- *
- * A boolean operator which checks whether `TFn` uses generics
- * to narrow the input parameters. This is in contrast to a function
- * which takes literal types rather than _extending_ them.
- *
- * **Related:** `NarrowingFn`, `IsLiteralFn`
- */
-export type IsNarrowingFn<TFn> = TFn extends AnyFunction
-? Not<IsEqual<
-    LiteralFn<TFn>,TFn
-  >>
-: false;

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

@@ -1,23 +0,0 @@
-import {
-  AsString,
-  IsEqual,
-  IsWideType,
-  NumberLike,
-} from "inferred-types/dist/types/index";
-
-/**
- * **IsNegativeNumber**`<T>`
- *
- * A boolean utility which returns true when `T` is a numerically
- * negative value. This includes string literal representations of
- * a number.
- */
-export type IsNegativeNumber<
-  T extends NumberLike
-> = IsWideType<T> extends true
-? boolean
-: IsEqual<T,NumberLike> extends true
-? boolean
-: AsString<T> extends `-${number}`
-  ? true
-  : false;

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

@@ -1,10 +0,0 @@
-import { As } from "../narrowing/As";
-
-/**
- * **IsNever**`<T>`
- *
- * Boolean type utility which check whether `T` is of type _never_.
- */
-export type IsNever<T> = As<[T] extends [never] ? true : false, boolean>;
-
-

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

@@ -1,23 +0,0 @@
-import {  If, IsUnion, RetainLiterals,  UnionToTuple } from "inferred-types/dist/types/index";
-
-
-type Process<T> = UnionToTuple<T> extends readonly unknown[]
-? RetainLiterals<UnionToTuple<T>>["length"] extends UnionToTuple<T>["length"]
-  ? false
-  : true
-: never;
-
-/**
- * **IsNonLiteralUnion**`<T>`
- *
- * Boolean utility which checks whether `T` is both a _union type_
- * and that none of it's elements are considered _literal types_.
- *
- * **Related:** `IsLiteralUnion`, `IsWideUnion`
- */
-export type IsNonLiteralUnion<
-  T> = If<
-  IsUnion<T>,
-  Process<T>,
-  false
->

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

@@ -1,7 +0,0 @@
-import { IsEqual } from "inferred-types/dist/types/index";
-/**
- * **NotEqual**`<X,Y>`
- *
- * Type utility which tests whether two types -- `X` and `Y` -- are _not_ exactly the same type
- */
-export type IsNotEqual<X, Y> = true extends IsEqual<X, Y> ? false : true;

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

@@ -1,11 +0,0 @@
-import { Nothing } from "inferred-types/dist/types/index";
-
-/**
- * **IsNothing**`<T>`
- *
- * Boolean operator which tests whether `T` is _nothing_ (aka.,
- * `null` or `undefined`).
- */
-export type IsNothing<T> = [T] extends [Nothing]
-? true
-: false;

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

@@ -1,17 +0,0 @@
-import { IsUnion } from "./IsUnion";
-
-/**
- * **IsNull**`<T>`
- * 
- * Type utility which returns a boolean flag based on whether the given
- * type is **null**.
- * 
- * Note: if `T` is a union type and one of the elements of the union
- * is `null` then this will return `boolean`.
- */
-export type IsNull<T> = IsUnion<T> extends true
-? [null] extends [T]
-  ? boolean
-  : false
-: [T] extends [null] ? true : false;
-

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

@@ -1,14 +0,0 @@
-import { IsUnion, WidenUnion } from "inferred-types/dist/types/index";
-
-/**
- * **IsNumber**`<T>`
- *
- * Boolean type utility testing whether `T` is a numeric type.
- */
-export type IsNumber<T> = [IsUnion<T>] extends [true]
-? WidenUnion<T> extends number
-  ? true
-  : number extends WidenUnion<T>
-    ? boolean
-    : false
-: [T] extends [number] ? true : false;

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

@@ -1,17 +0,0 @@
-import { DoesExtend } from "./DoesExtend";
-
-import { IsNever } from "./IsNever";
-import { IsNumber } from "./IsNumber";
-
-/**
- * **IsNumberLike**`<T>`
- *
- * Boolean operator which validates that `T` is a number or `${number}`
- */
-export type IsNumberLike<T> = IsNever<T> extends true
-? false
-: IsNumber<T> extends true
-? true
-: DoesExtend<T, `${number}`> extends true
-? true
-: false;

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

@@ -1,14 +0,0 @@
-import { IfNever, IfEqual, DoesExtend } from "inferred-types/dist/types/index";
-
-/**
- * **IsNumericLiteral**`<T>`
- *
- * Type utility which detects if the type `T` is a
- * numeric literal.
- */
-export type IsNumericLiteral<T> = IfNever<
-  T, never,
-  DoesExtend<T, number> extends true
-    ? IfEqual<T, number, false, true>
-    : false
->;

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

@@ -1,23 +0,0 @@
-import { AnyFunction , Mutable , Or, If, Extends } from "inferred-types/dist/types/index";
-
-/**
- * **IsObject**
- *
- * Boolean type utility used to check whether a type `T` is an object
- * (aka, it extends `Record<string, any>` or a readonly equivalent)
- */
-export type IsObject<T> = Or<[
-  If<Extends<T,Record<string|symbol, unknown>>, true, false>,
-  If<Extends<Mutable<T>,Record<string|symbol, unknown>>,true, false>,
-  If<Extends<T, object>, true, false>
-]> extends true
-? // an object of some type
-  T extends AnyFunction
-  ? // when a function with props is found, categorize as a function not object
-    false
-  : Mutable<T> extends unknown[]
-  ? // Array's are objects too but in our narrower definition we're looking only
-    // dictionary based arrays.
-    false
-  : true
-: false;

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

@@ -1,37 +0,0 @@
-
-import {
-  Dictionary,
-  UnionToTuple,
-  RemoveIndexKeys,
-  ExplicitlyEmptyObject,
-  IsEqual,
-  IsNever,
-} from "inferred-types/dist/types/index";
-
-type _Keys<
-  T extends Dictionary
-> = UnionToTuple<keyof RemoveIndexKeys<T>>;
-
-type CheckIt<T extends Dictionary> = IsNever<keyof T> extends true
-  ? false
-  : IsEqual<_Keys<T>, []> extends true
-    ? false
-    : true;
-
-
-/**
- * **IsObjectLiteral**`<T>`
- *
- * Tests whether an object is a literal. An object literal is any of the following:
- *
- * - any KV-like type which has an **explicit** number of keys
- * - if `Keys<T>["length"]` translates to `number` than this is **not** a literal.
- */
-export type IsObjectLiteral<T> = IsNever<T> extends true
-? false
-: T extends Dictionary
-? IsEqual<T, ExplicitlyEmptyObject> extends true
-  ? true
-  : CheckIt<T>
-: false
-

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

@@ -1,28 +0,0 @@
-import {
-  IsNever,
-  IsScalar,
-  IsUndefined,
-  IsUnion
-} from "inferred-types/dist/types/index";
-
-type Process<T> = [IsNever<T>] extends [true]
-? false
-: [IsScalar<T>] extends [true]
-  ? true
-  : [IsUndefined<T>] extends [true]
-    ? true
-    : [IsUnion<T>] extends [true]
-      ? boolean
-      : false;
-
-
-/**
- * **IsOptionalScalar**`<T>`
- *
- * Boolean type utility which tests for a _scalar_ value or _undefined_.
- *
- * **Related:** `IsScalar`
- */
-export type IsOptionalScalar<T> = Process<T> extends boolean
-? Process<T>
-: never;

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

@@ -1,13 +0,0 @@
-import { NumberLike } from "inferred-types/dist/types/index";
-import { IsNegativeNumber } from "./IsNegativeNumber";
-
-/**
- * **IsPositiveNumber**`<T>`
- *
- * Boolean operator which checks whether the value `T` is a _positive_ number.
- *
- * **Related:** `IsNegativeNumber`, `Abs`, `InvertNumericSign`
- */
-export type IsPositiveNumber<T extends NumberLike> = IsNegativeNumber<T> extends true
-? false
-: true;

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

@@ -1,14 +0,0 @@
-
-/**
- * **IsReadonlyArray**`<T>`
- * 
- * Boolean type utility which detects whether `T` is a readonly array.
- */
-export type IsReadonlyArray<T> = 
-
-T extends unknown[] 
-  ? false
-  : T extends readonly unknown[]
-  ? true 
-  : false;
-

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

@@ -1,15 +0,0 @@
-import {   Dictionary, ReadonlyKeys, IsEqual } from "inferred-types/dist/types/index";
-
-/**
- * **IsReadonlyObject**`<T>`
- *
- * Boolean operator which tests whether `T` is a _readonly
- * object_. This is defined as an object where all properties
- * are readonly.
- *
- * - Note: objects with no properties return `false`
- */
-export type IsReadonlyObject<T> = T extends Dictionary
-  ? IsEqual<ReadonlyKeys<T>, keyof T>
-  : false;
-

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

@@ -1,25 +0,0 @@
-import {
-  IfNever,
-  Scalar,
-} from "inferred-types/dist/types/index";
-
-
-
-
-/**
- * **IsScalar**`<T>`
- *
- * Type utility which checks if a value is a _scalar_ value (aka, it is
- * an atomic value and doesn't _contain_ other types). In practical terms this just
- * means if it's a string, number, boolean, null, or symbol then it is
- * a **scalar**. Arrays and records of any type are _not_ scalars.
- *
- * - Typically this resolves at design-time to true/false, however, in some
- * cases a union type can not resolve until runtime and a `boolean` value will
- * be returned.
- *
- * **Related:** `IsOptionalScalar`
- */
-export type IsScalar<T> = IfNever<T, false, T extends Scalar ? true : false>;
-
-

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

@@ -1,20 +0,0 @@
-import {
-  If,
-  IsStringLiteral,
-  Length
-} from "inferred-types/dist/types/index";
-
-/**
- * **IsSingleChar**`<T>`
- *
- * Boolean operator which returns true/false/boolean based on whether `T` is a
- */
-export type IsSingleChar<T> = T extends string
-  ? Length<T> extends 1
-    ? true
-    : If<
-        IsStringLiteral<T>,
-        false,
-        boolean
-      >
-  : false;

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

@@ -1,20 +0,0 @@
-import { If, IfNever, IsStringLiteral, SingularNoun } from "inferred-types/dist/types/index";
-
-
-/**
- * **IsSingularNoun**`<T>`
- *
- * Boolean operator which returns:
- *
- * - `true` - if `T` is a string literal with only `Alpha` chars and ending in
- * character defined by `SingularNounEnding`.
- * - `boolean` - if `T` is a wide string type
- * - `false` - all other conditions
- */
-export type IsSingularNoun<T> = T extends string
-  ? If<
-      IsStringLiteral<T>,
-      IfNever<SingularNoun<T>, false, true>,
-      boolean
-    >
-  : false;

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

@@ -1,16 +0,0 @@
-import {  WidenUnion, IsUnion } from "inferred-types/dist/types/index";
-
-/**
- * **IsString**
- *
- * Type utility which returns true/false based on whether `T` is a
- * string (wide or narrow).
- */
-export type IsString<T> = [IsUnion<T>] extends [true]
-? WidenUnion<T> extends string
-  ? true
-  : string extends WidenUnion<T>
-    ? boolean
-    : false
-: [T] extends [string] ? true : false;
-

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

@@ -1,16 +0,0 @@
-import {  IsEqual, IsNever } from "inferred-types/dist/types/index";
-
-/**
- * **IsStringLiteral**`<T>`
- *
- * Boolean type utility which detects whether `T` is
- * a string literal.
- */
-export type IsStringLiteral<T> = IsNever<T> extends true
-  ? false
-  : T extends string
-    ? IsEqual<T,string> extends true
-      ? false
-      : true
-    : false;
-

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

@@ -1,8 +0,0 @@
-/**
- * **IsSymbol**`<T>`
- * 
- * Type utility which returns a boolean flag based on whether the given
- * type is a **Symbol**.
- */
-export type IsSymbol<T> = T extends symbol ? true : false;
-

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

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

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

@@ -1,40 +0,0 @@
-import {
-  If,
-  IsNumericLiteral,
-  IsStringLiteral,
-  IsFalse,
-  IsTrue,
-  SomeEqual
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **IsTruthy**`<T>`
- *
- * A type utility which evaluates `T` for _[truthiness](https://frontend.turing.edu/lessons/module-1/js-truthy-falsy-expressions.html)_ and returns `true` or `false`
- * where the state can be detected at design time; otherwise returns `boolean`.
- *
- * **See Also:** `IfTruthy`, `IfSomeTruthy`, `IfAllTruthy`, and `TruthyReturns`
- */
-export type IsTruthy<T> = //
-  [T] extends [string]
-    ? T extends "" ? false : If<IsStringLiteral<T>, true, boolean>
-  : [T] extends [number]
-    ? If<
-        IsNumericLiteral<T>,
-        If<SomeEqual<[0, -0],T>,  false, true>, boolean>
-    : [T] extends [boolean]
-      ? If<
-          IsFalse<T>,
-          false,
-          If<
-            IsTrue<T>,
-            true,
-            boolean
-          >
-        >
-    : If<
-        SomeEqual<[null, undefined, typeof NaN],T>,
-        false,
-        boolean
-      >;