type-plus 6.3.0 → 6.4.0

package/ts/number/negative.ts

@@ -0,0 +1,109 @@
+import type { IsAny } from '../any/any_type.js'
+import type { IsNever } from '../never/never_type.js'
+import type { Zero } from './numeric_type.js'
+
+/**
+ * Check if 'T' is a negative numeric type.
+ *
+ * ```ts
+ * import type { Negative } from 'type-plus'
+ *
+ * type R = Negative<-1> // -1
+ * type R = Negative<-1n> // -1n
+ *
+ * type R = Negative<number> // number
+ * type R = Negative<any> // any
+ *
+ * type R = Negative<0> // never
+ * type R = Negative<1> // never
+ * ```
+ */
+export type Negative<T, Then = T, Else = never> = IsAny<
+	T,
+	Then | Else,
+	IsNever<
+		T,
+		Else,
+		[number, T] extends [T, number]
+			? Then
+			: [bigint, T] extends [T, bigint]
+			? Then
+			: T extends Zero
+			? Else
+			: [T] extends [number | bigint]
+			? `${T}` extends `-${string}`
+				? Then
+				: Else
+			: Else
+	>
+>
+
+/**
+ * Is 'T' a negative numeric type.
+ *
+ * ```ts
+ * import type { IsNegative } from 'type-plus'
+ *
+ * type R = IsNegative<-1> // true
+ * type R = IsNegative<-1n> // true
+ *
+ * type R = IsNegative<number> // boolean
+ * type R = IsNegative<any> // boolean
+ *
+ * type R = IsNegative<0> // false
+ * type R = IsNegative<1> // false
+ * ```
+ */
+export type IsNegative<T, Then = true, Else = false> = Negative<T, Then, Else>
+
+/**
+ * Check if 'T' is not a negative numeric type.
+ *
+ * ```ts
+ * import type { NotNegative } from 'type-plus'
+ *
+ * type R = NotNegative<-1> // never
+ * type R = NotNegative<-1n> // never
+ *
+ * type R = NotNegative<number> // number
+ * type R = NotNegative<any> // any
+ *
+ * type R = NotNegative<0> // 0
+ * type R = NotNegative<1> // 1
+ * ```
+ */
+export type NotNegative<T, Then = T, Else = never> = IsAny<
+	T,
+	Then | Else,
+	IsNever<
+		T,
+		Then,
+		[number, T] extends [T, number]
+			? Then
+			: [bigint, T] extends [T, bigint]
+			? Then
+			: [T] extends [number | bigint]
+			? `${T}` extends `-${string}`
+				? Else
+				: Then
+			: Then
+	>
+>
+
+/**
+ * Is 'T' not a negative numeric type.
+ *
+ * ```ts
+ * import type { IsNotNegative } from 'type-plus'
+ *
+ * type R = IsNotNegative<-1> // false
+ * type R = IsNotNegative<-1n> // false
+ *
+ * type R = IsNotNegative<number> // boolean
+ * type R = IsNotNegative<any> // boolean
+ *
+ * type R = IsNotNegative<0> // true
+ * type R = IsNotNegative<1> // true
+ * ```
+ */
+export type IsNotNegative<T, Then = true, Else = false> = NotNegative<T, Then, Else>

package/ts/number/number_array.ts

@@ -0,0 +1,15 @@
+import type { Add, IsStrictNumber } from '../index.js'
+
+export type Sum<A extends number[], Fail = never> = IsStrictNumber<
+	A['length'],
+	Fail,
+	A['length'] extends 0
+		? 0
+		: A['length'] extends 1
+		? A[0]
+		: A['length'] extends 2
+		? Add<A[0], A[1]>
+		: A extends [infer F extends number, infer S extends number, ...infer Tail extends number[]]
+		? Sum<[Add<F, S>, ...Tail]>
+		: never
+>

package/ts/number/number_plus.ts

@@ -0,0 +1,20 @@
+export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './integer.js'
+export type { IsNegative, IsNotNegative, Negative, NotNegative } from './negative.js'
+export type { Sum } from './number_array.js'
+export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number_type.js'
+export type {
+	IsNotNumeric,
+	IsNumeric,
+	NotNumericType,
+	Numeric,
+	NumericType,
+	Zero
+} from './numeric_type.js'
+export type { IsNotPositive, IsPositive, NonPositive, Positive } from './positive.js'
+export type {
+	IsNotStrictNumber,
+	IsStrictNumber,
+	NotStrictNumberType,
+	StrictNumberType
+} from './strict_number_type.js'
+

package/ts/number/number_type.ts

@@ -0,0 +1,61 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js'
+
+/**
+ * Check if the type `T` is `number`.
+ *
+ * ```ts
+ * import type { NumberType } from 'type-plus'
+ *
+ * type R = NumberType<number> // true
+ * type R = NumberType<1> // true
+ *
+ * type R = NumberType<never> // false
+ * type R = NumberType<unknown> // false
+ * ```
+ */
+export type NumberType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [number] ? Then : Else>
+
+/**
+ * Is the type `T` is `number`.
+ *
+ * ```ts
+ * import type { IsNumber } from 'type-plus'
+ *
+ * type R = IsNumber<number> // true
+ * type R = IsNumber<1> // true
+ *
+ * type R = IsNumber<never> // false
+ * type R = IsNumber<unknown> // false
+ * ```
+ */
+export type IsNumber<T, Then = true, Else = false> = NumberType<T, Then, Else>
+
+/**
+ * Check if the type `T` is not `number`.
+ *
+ * ```ts
+ * import type { NotNumberType } from 'type-plus'
+ *
+ * type R = NotNumberType<number> // false
+ * type R = NotNumberType<1> // false
+ *
+ * type R = NotNumberType<never> // true
+ * type R = NotNumberType<unknown> // true
+ * ```
+ */
+export type NotNumberType<T, Then = T, Else = never> = NumberType<T, Else, Then>
+
+/**
+ * Is the type `T` not `number`.
+ *
+ * ```ts
+ * import type { IsNotNumber } from 'type-plus'
+ *
+ * type R = IsNotNumber<number> // false
+ * type R = IsNotNumber<1> // false
+ *
+ * type R = IsNotNumber<never> // true
+ * type R = IsNotNumber<unknown> // true
+ * ```
+ */
+export type IsNotNumber<T, Then = true, Else = false> = NumberType<T, Else, Then>

package/ts/number/numeric_type.ts

@@ -0,0 +1,72 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js'
+
+/**
+ * Either number or bigint.
+ */
+export type Numeric = number | bigint
+
+/**
+ * The value 0 in number or bigint.
+ */
+export type Zero = 0 | 0n
+
+/**
+ * Check if `T` is numeric.
+ * Meaning it is either a `number` or a `bigint`.
+ *
+ * ```ts
+ * import type { NumericType } from 'type-plus'
+ *
+ * type R = NumericType<1> // 1
+ * type R = NumericType<1.1> // 1.1
+ *
+ * type R = NumericType<string> // never
+ * type R = NumericType<unknown> // never
+ * ```
+ */
+export type NumericType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [Numeric] ? Then : Else>
+
+/**
+ * Is `T` numeric.
+ *
+ * ```ts
+ * import type { IsNumeric } from 'type-plus'
+ *
+ * type R = IsNumeric<1> // true
+ * type R = IsNumeric<1.1> // true
+ *
+ * type R = IsNumeric<string> // false
+ * type R = IsNumeric<unknown> // false
+ * ```
+ */
+export type IsNumeric<T, Then = true, Else = false> = NumericType<T, Then, Else>
+
+/**
+ * Check if `T` is not numeric.
+ *
+ * ```ts
+ * import type { NotNumericType } from 'type-plus'
+ *
+ * type R = NotNumericType<1> // never
+ * type R = NotNumericType<1.1> // never
+ *
+ * type R = NotNumericType<string> // string
+ * type R = NotNumericType<unknown> // unknown
+ * ```
+ */
+export type NotNumericType<T, Then = T, Else = never> = NumericType<T, Else, Then>
+
+/**
+ * Is `T` not numeric.
+ *
+ * ```ts
+ * import type { IsNotNumeric } from 'type-plus'
+ *
+ * type R = IsNotNumeric<1> // false
+ * type R = IsNotNumeric<1.1> // false
+ *
+ * type R = IsNotNumeric<string> // true
+ * type R = IsNotNumeric<unknown> // true
+ * ```
+ */
+export type IsNotNumeric<T, Then = true, Else = false> = NumericType<T, Else, Then>

package/ts/number/positive.ts

@@ -0,0 +1,68 @@
+import { IsAny } from '../any/any_type.js'
+import { IsNever } from '../index.js'
+
+/**
+ * Check if `T` is a positive numeric type.
+ *
+ * ```ts
+ * import type { Positive } from 'type-plus'
+ *
+ * type R = Positive<1> // 1
+ * type R = Positive<0> // 0
+ * type R = Positive<1n> // 1n
+ *
+ * type R = Positive<-1> // never
+ * ```
+ */
+export type Positive<T, Then = T, Else = never> = IsAny<
+	T,
+	Then | Else,
+	IsNever<T, Else, T extends number | bigint ? (`${T}` extends `-${string}` ? Else : Then) : Else>
+>
+
+/**
+ * Is `T` a positive numeric type.
+ *
+ * ```ts
+ * import type { IsPositive } from 'type-plus'
+ *
+ * type R = IsPositive<1> // true
+ * type R = IsPositive<0> // true
+ * type R = IsPositive<1n> // true
+ *
+ * type R = IsPositive<number> // boolean
+ * type R = IsPositive<bigint> // boolean
+ * type R = IsPosistive<any> // boolean
+ *
+ * type R = IsPositive<-1> // false
+ * ```
+ */
+export type IsPositive<T, Then = true, Else = false> = Positive<T, Then, Else>
+
+/**
+ * Check if `T` is not a positive numeric type.
+ *
+ * ```ts
+ * import type { NonPositive } from 'type-plus'
+ *
+ * type R = NonPositive<-1> // -1
+ *
+ * type R = NonPositive<0> // never
+ * type R = NonPositive<1> // never
+ * ```
+ */
+export type NonPositive<T, Then = T, Else = never> = Positive<T, Else, Then>
+
+/**
+ * Is `T` not a positive numeric type.
+ *
+ * ```ts
+ * import type { IsNotPositive } from 'type-plus'
+ *
+ * type R = IsNotPositive<-1> // true
+ *
+ * type R = IsNotPositive<0> // false
+ * type R = IsNotPositive<1> // false
+ * ```
+ */
+export type IsNotPositive<T, Then = true, Else = false> = Positive<T, Else, Then>

package/ts/number/readme.md

@@ -0,0 +1,155 @@
+# number
+
+## Type Checking
+
+The `NumberType<T>` and friends are used to check if `T` is `number` or number literals.
+
+```ts
+import type { NumberType } from 'type-plus'
+
+type R = NumberType<number> // number
+type R = NumberType<1> // 1
+
+type R = NumberType<bigint> // never
+type R = NumberType<1n> // never
+type R = NumberType<never> // never
+type R = NumberType<unknown> // never
+```
+
+- [`NumberType<T, Then = T, Else = never>`](number_type.ts#L16): check if `T` is `number` or number literals.
+- [`IsNumber<T, Then = true, Else = false`](number_type.ts#L35): is `T` `number` or number literals.
+- [`NotNumberType<T, Then = T, Else = never>`](number_type.ts#L46): check if `T` is not `number` nor number literals.
+- [`IsNotNumber<T, Then = true, Else = false>`](number_type.ts#L61): is `T` not `number` nor number literals.
+
+---
+
+The `StrictNumberType<T>` and friends are used to check if `T` is exactly `number`.
+
+```ts
+import type { StrictNumberType } from 'type-plus'
+
+type R = StrictNumberType<number> // number
+
+type R = StrictNumberType<1> // never
+type R = StrictNumberType<never> // never
+type R = StrictNumberType<unknown> // never
+```
+
+- [`StrictNumberType<T, Then = T, Else = never>`](strict_number_type.ts#L16): check if `T` is `number`.
+- [`IsStrictNumber<T, Then = true, Else = false`](strict_number_type.ts#L35): is `T` `number`.
+- [`NotStrictNumberType<T, Then = T, Else = never>`](strict_number_type.ts#L50): check if `T` is not `number`.
+- [`IsNotStrictNumber<T, Then = true, Else = false>`](strict_number_type.ts#L65): is `T` not `number`.
+
+---
+
+`Numeric` type is either `number` or `bigint`.
+
+The `NumericType<T>` and friends are used to check if `T` is `number` or `bigint`.
+
+```ts
+import type { NumericType } from 'type-plus'
+
+type R = NumericType<number> // number
+type R = NumericType<bigint> // bigint
+type R = NumericType<1> // 1
+type R = NumericType<1n> // 1n
+
+type R = NumericType<never> // never
+```
+
+- [`NumericType<T, Then = T, Else = never>`](numeric_type.ts#L27): check if `T` is `number` or `bigint`.
+- [`IsNumeric<T, Then = true, Else = false>`](numeric_type.ts#L42): is `T` `number` or `bigint`.
+- [`NotNumericType<T, Then = T, Else = never>`](numeric_type.ts#L57): check if `T` is not `number` nor `bigint`.
+- [`IsNotNumeric<T, Then = true, Else = false>`](numeric_type.ts#L72): is `T` not `number` nor `bigint`.
+
+---
+
+`Integer<T>` and friends are used to check if `T` is an integer.
+
+```ts
+import type { Integer } from 'type-plus'
+
+type R = Integer<1> // 1
+type R = Integer<1.0> // 1.0
+
+type R = Integer<1.1> // never
+```
+
+- [`Integer<T, Then = T, Else = never>`](integer.ts#L17): check if `T` is an integer.
+- [`IsInteger<T, Then = true, Else = false>`](integer.ts#L36): is `T` an integer.
+- [`NotIntegerType<T, Then = T, Else = never>`](integer.ts#L51): check if `T` is not an integer.
+- [`IsNotInteger<T, Then = true, Else = false>`](integer.ts#L66): is `T` not an integer.
+- [`IsWhole<T, Then = true, Else = false>`](integer.ts#L81): same as `Integer<T>`, will be deprecated in the future.
+
+---
+
+`Positive<T>` and friends are used to check if `T` is a positive numeric value.
+
+The `number` and `bigint` can be considered as a union of all positive and negative numeric literals.
+
+That is why `IsPositive<T>` will yield `boolean` as the union is distributive.
+`Positive<T>` returns `T` for `number` and `bigint` for the same reason.
+It is a bit confusing but it is correct as it really returns `T | never`,
+which resolves to `T`.
+
+This behavior is different than `TrueType<T>` which `TrueType<boolean>` returns `never`.
+
+This is because `TrueType<T>` is checking for the exect `true` type,
+while `Positive<T>` is checking for a criteria of types (i.e. a set).
+
+```ts
+import type { Positive } from 'type-plus'
+
+type R = Positive<1> // 1
+type R = Positive<1.0> // 1.0
+type R = Positive<1n> // 1n
+
+type R = Positive<-1> // never
+type R = Positive<'1'> // never
+```
+
+- [`Positive<T, Then = T, Else = never>`](positive.ts#L17): check if `T` is a positive numeric value.
+- [`IsPositive<T, Then = true, Else = false>`](positive.ts#L40): is `T` a positive numeric value.
+- [`NotPositiveType<T, Then = T, Else = never>`](positive.ts#L54): check if `T` is not a positive numeric value.
+- [`IsNotPositive<T, Then = true, Else = false>`](positive.ts#L68): is `T` not a positive numeric value.
+
+---
+
+`Negative<T>` and friends are used to check if `T` is a negative numeric value.
+
+The `number` and `bigint` can be considered as a union of all negative and negative numeric literals.
+
+That is why `IsNegative<T>` will yield `boolean` as the union is distributive.
+`Negative<T>` returns `T` for `number` and `bigint` for the same reason.
+It is a bit confusing but it is correct as it really returns `T | never`,
+which resolves to `T`.
+
+This behavior is different than `TrueType<T>` which `TrueType<boolean>` returns `never`.
+
+This is because `TrueType<T>` is checking for the exect `true` type,
+while `Negative<T>` is checking for a criteria of types (i.e. a set).
+
+```ts
+import type { Negative } from 'type-plus'
+
+type R = Negative<1> // never
+type R = Negative<1.0> // never
+type R = Negative<1n> // never
+
+type R = Negative<number> // number
+type R = Negative<any> // any
+
+type R = Negative<-1> // -1
+type R = Negative<'1'> // '1'
+```
+
+- [`Negative<T, Then = T, Else = never>`](negative.ts#L21): check if `T` is a negative numeric value.
+- [`IsNegative<T, Then = true, Else = false>`](negative.ts#L57): is `T` a negative numeric value.
+- [`NotNegativeType<T, Then = T, Else = never>`](negative.ts#L75): check if `T` is not a negative numeric value.
+- [`IsNotNegative<T, Then = true, Else = false>`](negative.ts#L109): is `T` not a negative numeric value.
+
+## References
+
+- [Handbook]
+
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#the-primitives-string-number-and-boolean

package/ts/number/strict_number_type.ts

@@ -0,0 +1,65 @@
+import type { IsAny } from '../any/any_type.js'
+
+/**
+ * Check if the type `T` is exactly the type `number` and not numeric literals.
+ *
+ * ```ts
+ * import type { StrictNumberType } from 'type-plus'
+ *
+ * type R = StrictNumberType<number> // true
+ * type R = StrictNumberType<1> // false
+ *
+ * type R = StrictNumberType<never> // false
+ * type R = StrictNumberType<unknown> // false
+ * ```
+ */
+export type StrictNumberType<T, Then = T, Else = never> = IsAny<
+	T,
+	Else,
+	[number, T] extends [T, number] ? Then : Else
+>
+
+/**
+ * Is the type `T` exactly the type `number` and not numeric literals.
+ *
+ * ```ts
+ * import type { IsStrictNumber } from 'type-plus'
+ *
+ * type R = IsStrictNumber<number> // true
+ * type R = IsStrictNumber<1> // false
+ *
+ * type R = IsStrictNumber<never> // false
+ * type R = IsStrictNumber<unknown> // false
+ * ```
+ */
+export type IsStrictNumber<T, Then = true, Else = false> = StrictNumberType<T, Then, Else>
+
+/**
+ * Check if the type `T` is not the type `number` or numeric literals.
+ *
+ * ```ts
+ * import type { NotStictNumberType } from 'type-plus'
+ *
+ * type R = NotStictNumberType<number> // false
+ * type R = NotStictNumberType<1> // true
+ *
+ * type R = NotStictNumberType<never> // true
+ * type R = NotStictNumberType<unknown> // true
+ * ```
+ */
+export type NotStrictNumberType<T, Then = T, Else = never> = StrictNumberType<T, Else, Then>
+
+/**
+ * Is the type `T` not the type `number` or numeric literals.
+ *
+ * ```ts
+ * import type { IsNotStrictNumber } from 'type-plus'
+ *
+ * type R = IsNotStrictNumber<number> // false
+ * type R = IsNotStrictNumber<1> // true
+ *
+ * type R = IsNotStrictNumber<never> // true
+ * type R = IsNotStrictNumber<unknown> // true
+ * ```
+ */
+export type IsNotStrictNumber<T, Then = true, Else = false> = StrictNumberType<T, Else, Then>

package/ts/object/ANotB.ts

@@ -1,4 +1,4 @@
-import type { Equal } from '../predicates/index.js'
+import { Equal } from '../equal/equal.js'
 import type { AnyRecord } from './AnyRecord.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'

package/ts/object/KnownKeys.ts

@@ -2,7 +2,7 @@
 // known from Gerrit Birkeland @Gerrit0
 // https://github.com/Microsoft/TypeScript/issues/25987#issuecomment-408339599
 
-import type { PrimitiveTypes } from '../PrimitiveTypes.js'
+import type { PrimitiveTypes } from '../primitive.js'
 
 // https://github.com/microsoft/TypeScript/issues/25987#issuecomment-441224690
 export type KnownKeys<T> = T extends PrimitiveTypes

package/ts/object/Partial.ts

@@ -1,4 +1,4 @@
-import type { UnionKeys } from '../UnionKeys.js'
+import type { UnionKeys } from '../union_keys.js'
 import type { Omit } from './omit.js'
 import type { Pick } from './pick.js'
 

package/ts/object/getField.ts

@@ -1,4 +1,4 @@
-import type { UnionKeys } from '../UnionKeys.js'
+import type { UnionKeys } from '../union_keys.js'
 
 export function getField<T, TX extends Exclude<T, undefined | null>, K extends UnionKeys<TX>>(
 	subject: T,

package/ts/object/hasProperty.ts

@@ -1,4 +1,4 @@
-import { UnionKeys } from '../UnionKeys.js'
+import { UnionKeys } from '../union_keys.js'
 
 export function hasProperty<T, P extends UnionKeys<T>>(value: T, prop: P): value is T & Record<P, T[P]> {
 	return !!value[prop]

package/ts/object/index.ts

@@ -1,7 +1,22 @@
 export type { ANotB, BNotA, LeftJoin } from './ANotB.js'
 export type { AnyRecord } from './AnyRecord.js'
-export * from './everyKey.js'
 export type { ExcludePropType } from './ExcludePropType.js'
+export type { IsDisjoint } from './IsDisjoint.js'
+export type { IsRecord } from './IsRecord.js'
+export type { KeyTypes } from './KeyTypes.js'
+export type { KeysOfOptional } from './KeyofOptional.js'
+export type { KeysWithDiffType } from './KeysWithDiffType.js'
+export type { KnownKeys } from './KnownKeys.js'
+export type { OptionalKeys } from './OptionalKeys.js'
+export type { PartialExcept, PartialOmit, PartialPick } from './Partial.js'
+export type { RecursiveIntersect } from './RecursiveIntersect.js'
+export type { RecursivePartial } from './RecursivePartial.js'
+export type { RecursiveRequired } from './RecursiveRequired.js'
+export type { RequiredExcept, RequiredPick } from './Required.js'
+export type { RequiredKeys } from './RequiredKeys.js'
+export type { SpreadRecord } from './SpreadRecord.js'
+export type { ValueOf } from './ValueOf.js'
+export * from './everyKey.js'
 export * from './facade.js'
 export * from './filterKey.js'
 export * from './findKey.js'
@@ -9,28 +24,14 @@ export * from './forEachKey.js'
 export * from './getField.js'
 export * from './hasKey.js'
 export * from './hasProperty.js'
-export type { IsDisjoint } from './IsDisjoint.js'
-export type { IsRecord } from './IsRecord.js'
-export type { KeysOfOptional } from './KeyofOptional.js'
-export type { KeysWithDiffType } from './KeysWithDiffType.js'
-export type { KeyTypes } from './KeyTypes.js'
-export type { KnownKeys } from './KnownKeys.js'
 export * from './mapKey.js'
 export * from './mapProperties.js'
 export * from './omit.js'
-export type { OptionalKeys } from './OptionalKeys.js'
-export type { PartialExcept, PartialOmit, PartialPick } from './Partial.js'
 export * from './pick.js'
+export type { Properties } from './properties.js'
 export * from './record.js'
-export type { RecursiveIntersect } from './RecursiveIntersect.js'
-export type { RecursivePartial } from './RecursivePartial.js'
-export type { RecursiveRequired } from './RecursiveRequired.js'
 export * from './reduceKey.js'
 export * from './replaceProperty.js'
-export type { RequiredExcept, RequiredPick } from './Required.js'
-export type { RequiredKeys } from './RequiredKeys.js'
 export * from './someKey.js'
 export * from './split.js'
-export type { SpreadRecord } from './SpreadRecord.js'
 export * from './typeOverrideIncompatible.js'
-export type { ValueOf } from './ValueOf.js'