type-plus 4.8.0 → 4.9.0

package/README.md

@@ -415,8 +415,8 @@ So you may encounter some weird behavior if your logic is complex.
 - `Abs<N, Fail=never>`: `Abs(N)`, `Abs<number>` returns `Fail`.
 - `IsPositive<N>`: is `N` a positive number literal. `IsPositive<number>` returns `false`.
 - `IsWhole<N>`: is `N` a whole number literal. `IsWhole<number>` returns `false`.
-- `Max<A, B, Fail=never>`: `max(A, B)`, for positive and whole number, `Fail` otherwise.
-- `GreaterThan<A, B, Fail=never>`: `A > B` for positive and whole numbers, `Fail` otherwise.
+- `Max<A, B, Fail=never>`: `max(A, B)`, for whole number, `Fail` otherwise.
+- `GreaterThan<A, B, Fail=never>`: `A > B` for whole numbers, `Fail` otherwise.
 
 #### Arithmetics
 

package/cjs/math/Digit.d.ts

@@ -48,6 +48,8 @@ export declare namespace DigitArray {
     type ToTuple<R extends any[], S extends number[], X = any> = S['length'] extends 0 ? R : (S['length'] extends 1 ? [...R, ...Digit.ToTuple<X>[S[0]]] : (S extends [any, ...infer T] ? (T extends any[] ? ToTuple<Multi10<[...R, ...Digit.ToTuple<X>[S[0]]]>, T> : never) : never));
     type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C];
     type FromNumber<N extends number> = FromString<NumberToString<N>>;
+    type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>;
+    type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N;
     type NumberToString<N extends number> = (And<IsPositive<N>, IsWhole<N>>) extends true ? `${N}` : never;
     type FromString<S extends string> = S extends `1${infer L}` ? [1, ...FromString<L>] : S extends `2${infer L}` ? [2, ...FromString<L>] : S extends `3${infer L}` ? [3, ...FromString<L>] : S extends `4${infer L}` ? [4, ...FromString<L>] : S extends `5${infer L}` ? [5, ...FromString<L>] : S extends `6${infer L}` ? [6, ...FromString<L>] : S extends `7${infer L}` ? [7, ...FromString<L>] : S extends `8${infer L}` ? [8, ...FromString<L>] : S extends `9${infer L}` ? [9, ...FromString<L>] : S extends `0${infer L}` ? [0, ...FromString<L>] : [];
     type Shift10<DA extends number[]> = TrimLeadingZero<Shift10State<[], DA>>;

package/cjs/math/GreaterThan.d.ts

@@ -1,11 +1,11 @@
 import type { Head, PadLeft, Tail } from '../array';
-import type { And, Equal } from '../predicates';
+import type { And, Equal, Or, Xor } from '../predicates';
 import type { Digit, DigitArray } from './Digit';
 import type { IsPositive } from './IsPositive';
 import type { IsWhole } from './IsWhole';
 import type { Max } from './Max';
-export declare type GreaterThan<A extends number, B extends number, Fail = never> = And<And<IsPositive<A>, IsWhole<A>>, And<IsPositive<B>, IsWhole<B>>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? false : GreaterThan.OnPositiveWhole<A, B>;
+export declare type GreaterThan<A extends number, B extends number, Fail = never> = And<IsWhole<A>, IsWhole<B>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? false : Xor<IsPositive<A>, IsPositive<B>> extends true ? IsPositive<A> : Or<IsPositive<A>, IsPositive<B>> extends false ? GreaterThan.ForWholeNumber<B, A> : GreaterThan.ForWholeNumber<A, B>;
 export declare namespace GreaterThan {
-    type OnPositiveWhole<A extends number, B extends number> = (DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? OnDigitArray<PDA, PDB> : never : never : never : never : never : never : never : never : never : never);
-    type OnDigitArray<DA extends number[], DB extends number[]> = (Equal<Head<DA>, Head<DB>> extends true ? OnDigitArray<Tail<DA>, Tail<DB>> extends Tail<DA> ? true : false : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? true : false);
+    type ForWholeNumber<A extends number, B extends number> = (DigitArray.FromNumberAbs<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumberAbs<B> extends infer DB ? DB extends number[] ? Max<DA['length'], DB['length']> extends infer M ? M extends number ? PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ? PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ? ForDigitArray<PDA, PDB> : never : never : never : never : never : never : never : never : never : never);
+    type ForDigitArray<DA extends number[], DB extends number[]> = (Equal<Head<DA>, Head<DB>> extends true ? ForDigitArray<Tail<DA>, Tail<DB>> : Digit.GreaterThan<Head<DA>, Head<DB>>);
 }

package/cjs/math/Max.d.ts

@@ -1,10 +1,3 @@
-import type { Head, Tail } from '../array';
-import type { And, Equal } from '../predicates';
-import type { Digit, DigitArray } from './Digit';
-import type { IsPositive } from './IsPositive';
-import type { IsWhole } from './IsWhole';
-export declare type Max<A extends number, B extends number, Fail = never> = And<IsPositive<A>, IsWhole<A>> extends false ? Fail : And<IsPositive<B>, IsWhole<B>> extends false ? Fail : number extends A ? Fail : number extends B ? Fail : Equal<A, B> extends true ? A : Max.OnPositiveWhole<A, B>;
-export declare namespace Max {
-    type OnPositiveWhole<A extends number, B extends number> = (DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ? DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ? OnDigitArray<DA, DB> extends DA ? A : B : never : never : never : never);
-    type OnDigitArray<DA extends number[], DB extends number[]> = Equal<DA['length'], DB['length']> extends true ? (Equal<Head<DA>, Head<DB>> extends true ? (Tail<DA> extends infer TDA ? TDA extends number[] ? OnDigitArray<TDA, Tail<DB>> extends TDA ? DA : DB : never : never) : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? DA : DB) : OnPositiveWhole<DA['length'], DB['length']> extends DA['length'] ? DA : DB;
-}
+import type { Equal } from '../predicates';
+import { GreaterThan } from './GreaterThan';
+export declare type Max<A extends number, B extends number, Fail = never> = GreaterThan<A, B> extends infer Result ? Equal<Result, never> extends true ? Fail : Result extends true ? A : B : never;

package/cjs/object/split.d.ts

@@ -4,7 +4,7 @@ declare type Splitter<T extends AnyRecord> = Partial<{
     [k in keyof T]: T[k] | undefined;
 }>;
 export declare type Split<T extends AnyRecord, S extends AnyRecord> = {
-    [k in keyof S]: S[k] extends undefined ? T[k] : NonNullable<T[k]> | S[k];
+    [k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | S[k];
 };
 export declare function split<T extends AnyRecord, S1 extends Splitter<T>>(target: T, split1: S1): [
     Split<T, S1>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-plus",
-  "version": "4.8.0",
+  "version": "4.9.0",
   "description": "Provides additional types for TypeScript.",
   "homepage": "https://github.com/unional/type-plus",
   "bugs": {

package/ts/math/Digit.ts

@@ -66,6 +66,8 @@ export namespace DigitArray {
 
 
   export type FromNumber<N extends number> = FromString<NumberToString<N>>
+  export type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>
+  export type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N
 
   export type NumberToString<N extends number> = (And<IsPositive<N>, IsWhole<N>>) extends true ? `${N}` : never
 

package/ts/math/GreaterThan.spec.ts

@@ -1,40 +1,75 @@
-import { GreaterThan, isType } from '..'
-
-test('only support positive and whole number', () => {
-  isType.equal<true, never, GreaterThan<0.1, 1>>()
-  isType.equal<true, never, GreaterThan<-1, 1>>()
-  isType.equal<true, never, GreaterThan<1, 0.1>>()
-  isType.equal<true, never, GreaterThan<1, -1>>()
-})
-
-test('number gets never', () => {
-  isType.equal<true, never, GreaterThan<number, 1>>()
-  isType.equal<true, never, GreaterThan<1, number>>()
-})
-
-test('override Fail case', () => {
-  isType.equal<true, number, GreaterThan<number, 1, number>>()
-})
-
-test('n > n is false', () => {
-  isType.f<GreaterThan<0, 0>>()
-  isType.f<GreaterThan<1, 1>>()
-  isType.f<GreaterThan<12, 12>>()
-})
-
-test('with same number of digits', () => {
-  isType.t<GreaterThan<1, 0>>()
-  isType.t<GreaterThan<22, 11>>()
-  isType.t<GreaterThan<20, 19>>()
-
-  isType.f<GreaterThan<0, 1>>()
-  isType.f<GreaterThan<11, 22>>()
-  isType.f<GreaterThan<19, 20>>()
-})
-
-test('with different number of digits', () => {
-  isType.f<GreaterThan<0, 1>>()
-  isType.f<GreaterThan<9, 100>>()
-  isType.t<GreaterThan<10, 1>>()
-  isType.t<GreaterThan<123, 32>>()
-})
+import { GreaterThan, isType } from '..'
+
+test('only support whole number', () => {
+  isType.equal<true, never, GreaterThan<0.1, 1>>()
+  isType.equal<true, never, GreaterThan<1, 0.1>>()
+})
+
+test('number gets never', () => {
+  isType.equal<true, never, GreaterThan<number, 1>>()
+  isType.equal<true, never, GreaterThan<1, number>>()
+})
+
+test('override Fail case', () => {
+  isType.equal<true, number, GreaterThan<number, 2, number>>()
+})
+
+test('n > n is false', () => {
+  isType.equal<true, false, GreaterThan<0, 0>>()
+  isType.equal<true, false, GreaterThan<1, 1>>()
+  isType.equal<true, false, GreaterThan<12, 12>>()
+})
+
+test('with same number of digits', () => {
+  isType.equal<true, true, GreaterThan<1, 0>>()
+  isType.equal<true, true, GreaterThan<22, 11>>()
+  isType.equal<true, true, GreaterThan<20, 19>>()
+  isType.equal<true, true, GreaterThan<19, 10>>()
+
+  isType.equal<true, false, GreaterThan<0, 1>>()
+  isType.equal<true, false, GreaterThan<11, 22>>()
+  isType.equal<true, false, GreaterThan<19, 20>>()
+  isType.equal<true, false, GreaterThan<10, 19>>()
+})
+
+test('with different number of digits', () => {
+  isType.equal<true, false, GreaterThan<0, 1>>()
+  isType.equal<true, false, GreaterThan<9, 100>>()
+  isType.equal<true, true, GreaterThan<10, 1>>()
+  isType.equal<true, true, GreaterThan<123, 32>>()
+  isType.equal<true, true, GreaterThan<123, 13>>()
+})
+
+test('-0 > 0 and 0 > -0 are false', () => {
+  isType.equal<true, false, GreaterThan<-0, 0>>()
+  isType.equal<true, false, GreaterThan<0, -0>>()
+})
+
+test('works with negative numbers', () => {
+  isType.equal<true, true, GreaterThan<0, -1>>()
+  isType.equal<true, true, GreaterThan<1, -1>>()
+  isType.equal<true, true, GreaterThan<2, -1>>()
+
+  isType.equal<true, false, GreaterThan<-1, 0>>()
+  isType.equal<true, false, GreaterThan<-1, 1>>()
+  isType.equal<true, false, GreaterThan<-1, 2>>()
+
+  isType.equal<true, false, GreaterThan<-0, -0>>()
+  isType.equal<true, false, GreaterThan<-1, -1>>()
+
+  isType.equal<true, true, GreaterThan<-0, -1>>()
+  isType.equal<true, false, GreaterThan<-1, -1>>()
+  isType.equal<true, false, GreaterThan<-2, -1>>()
+
+  isType.equal<true, false, GreaterThan<-1, -0>>()
+  isType.equal<true, false, GreaterThan<-1, -1>>()
+  isType.equal<true, true, GreaterThan<-1, -2>>()
+})
+
+test('work with large numbers', () => {
+  isType.equal<true, true, GreaterThan<1000000, 0>>()
+  isType.equal<true, false, GreaterThan<0, 1000000>>()
+
+  isType.equal<true, false, GreaterThan<-1000000, 0>>()
+  isType.equal<true, true, GreaterThan<0, -1000000>>()
+})

package/ts/math/GreaterThan.ts

@@ -1,28 +1,27 @@
 import type { Head, PadLeft, Tail } from '../array'
-import type { And, Equal } from '../predicates'
+import type { And, Equal, Or, Xor } from '../predicates'
 import type { Digit, DigitArray } from './Digit'
 import type { IsPositive } from './IsPositive'
 import type { IsWhole } from './IsWhole'
 import type { Max } from './Max'
 
 export type GreaterThan<A extends number, B extends number, Fail = never> =
-  And<
-    And<IsPositive<A>, IsWhole<A>>,
-    And<IsPositive<B>, IsWhole<B>>
-  > extends false ? Fail :
+  And<IsWhole<A>, IsWhole<B>> extends false ? Fail :
   number extends A ? Fail :
   number extends B ? Fail :
   Equal<A, B> extends true ? false :
-  GreaterThan.OnPositiveWhole<A, B>
+  Xor<IsPositive<A>, IsPositive<B>> extends true ? IsPositive<A> :
+  Or<IsPositive<A>, IsPositive<B>> extends false ? GreaterThan.ForWholeNumber<B, A> :
+  GreaterThan.ForWholeNumber<A, B>
 
 export namespace GreaterThan {
-  export type OnPositiveWhole<A extends number, B extends number> = (
-    DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
+  export type ForWholeNumber<A extends number, B extends number> = (
+    DigitArray.FromNumberAbs<A> extends infer DA ? DA extends number[] ?
+    DigitArray.FromNumberAbs<B> extends infer DB ? DB extends number[] ?
     Max<DA['length'], DB['length']> extends infer M ? M extends number ?
     PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
     PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    OnDigitArray<PDA, PDB>
+    ForDigitArray<PDA, PDB>
     : never : never
     : never : never
     : never : never
@@ -30,9 +29,9 @@ export namespace GreaterThan {
     : never : never
   )
 
-  export type OnDigitArray<DA extends number[], DB extends number[]> = (
-    Equal<Head<DA>, Head<DB>> extends true ?
-    OnDigitArray<Tail<DA>, Tail<DB>> extends Tail<DA> ? true : false :
-    Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? true : false
+  export type ForDigitArray<DA extends number[], DB extends number[]> = (
+    Equal<Head<DA>, Head<DB>> extends true
+    ? ForDigitArray<Tail<DA>, Tail<DB>>
+    : Digit.GreaterThan<Head<DA>, Head<DB>>
   )
 }

package/ts/math/Max.spec.ts

@@ -1,35 +1,59 @@
-import { isType, Max } from '..'
-
-test('only support positive and whole number', () => {
-  isType.equal<true, never, Max<0.1, 1>>()
-  isType.equal<true, never, Max<-1, 1>>()
-  isType.equal<true, never, Max<1, 0.1>>()
-  isType.equal<true, never, Max<1, -1>>()
-})
-
-test('number gets never', () => {
-  isType.equal<true, never, Max<number, 1>>()
-  isType.equal<true, never, Max<1, number>>()
-})
-
-test('override Fail case', () => {
-  isType.equal<true, number, Max<number, 1, number>>()
-})
-
-test('same number', () => {
-  isType.equal<true, 123, Max<123, 123>>()
-})
-
-test('same number of digits', () => {
-  isType.equal<true, 124, Max<123, 124>>()
-  isType.equal<true, 126, Max<126, 124>>()
-  isType.equal<true, 224, Max<126, 224>>()
-  isType.equal<true, 726, Max<726, 224>>()
-})
-
-test('more digits win', () => {
-  isType.equal<true, 123, Max<123, 22>>()
-  isType.equal<true, 223, Max<12, 223>>()
-  isType.equal<true, 1234567891011, Max<1234567891011, 123>>()
-  isType.equal<true, 1234567891011, Max<123, 1234567891011>>()
-})
+import { isType, Max } from '..'
+
+test('only support whole number', () => {
+  isType.equal<true, never, Max<0.1, 1>>()
+  isType.equal<true, never, Max<1, 0.1>>()
+})
+
+test('number gets never', () => {
+  isType.equal<true, never, Max<number, 1>>()
+  isType.equal<true, never, Max<1, number>>()
+})
+
+test('override Fail case', () => {
+  isType.equal<true, number, Max<number, 1, number>>()
+})
+
+test('same number', () => {
+  isType.equal<true, 123, Max<123, 123>>()
+})
+
+test('same number of digits', () => {
+  isType.equal<true, 124, Max<123, 124>>()
+  isType.equal<true, 126, Max<126, 124>>()
+  isType.equal<true, 224, Max<126, 224>>()
+  isType.equal<true, 726, Max<726, 224>>()
+})
+
+test('more digits win', () => {
+  isType.equal<true, 123, Max<123, 22>>()
+  isType.equal<true, 223, Max<12, 223>>()
+  isType.equal<true, 1234567891011, Max<1234567891011, 123>>()
+  isType.equal<true, 1234567891011, Max<123, 1234567891011>>()
+})
+
+test('work with negative numbers', () => {
+  isType.equal<true, 0, Max<0, -0>>()
+  isType.equal<true, 0, Max<-0, 0>>()
+  isType.equal<true, 0, Max<-0, -0>>()
+
+  isType.equal<true, 0, Max<0, -1>>()
+  isType.equal<true, 1, Max<1, -1>>()
+  isType.equal<true, 2, Max<2, -1>>()
+
+  isType.equal<true, 0, Max<-1, 0>>()
+  isType.equal<true, 1, Max<-1, 1>>()
+  isType.equal<true, 2, Max<-1, 2>>()
+
+  isType.equal<true, -1, Max<-1, -2>>()
+  isType.equal<true, -2, Max<-2, -2>>()
+  isType.equal<true, -2, Max<-3, -2>>()
+})
+
+test('work with large numbers', () => {
+  isType.equal<true, 1000000, Max<1000000, 0>>()
+  isType.equal<true, 1000000, Max<0, 1000000>>()
+
+  isType.equal<true, 0, Max<-1000000, 0>>()
+  isType.equal<true, 0, Max<0, -1000000>>()
+})

package/ts/math/Max.ts

@@ -1,32 +1,8 @@
-import type { Head, Tail } from '../array'
-import type { And, Equal } from '../predicates'
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
+import type { Equal } from '../predicates'
+import { GreaterThan } from './GreaterThan'
 
 export type Max<A extends number, B extends number, Fail = never> =
-  And<IsPositive<A>, IsWhole<A>> extends false ? Fail :
-  And<IsPositive<B>, IsWhole<B>> extends false ? Fail :
-  number extends A ? Fail :
-  number extends B ? Fail :
-  Equal<A, B> extends true ? A :
-  Max.OnPositiveWhole<A, B>
-
-export namespace Max {
-  export type OnPositiveWhole<A extends number, B extends number> = (
-    DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-    OnDigitArray<DA, DB> extends DA ? A : B
-    : never : never
-    : never : never
-  )
-
-  export type OnDigitArray<DA extends number[], DB extends number[]> =
-    Equal<DA['length'], DB['length']> extends true
-    ? (Equal<Head<DA>, Head<DB>> extends true
-      ? (Tail<DA> extends infer TDA ? TDA extends number[] ?
-        OnDigitArray<TDA, Tail<DB>> extends TDA ? DA : DB
-        : never : never)
-      : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? DA : DB)
-    : OnPositiveWhole<DA['length'], DB['length']> extends DA['length'] ? DA : DB
-}
+  GreaterThan<A, B> extends infer Result ?
+  Equal<Result, never> extends true ? Fail :
+  Result extends true ? A : B
+  : never

package/ts/object/split.spec.ts

@@ -35,6 +35,24 @@ test('can default with null', () => {
   isType.equal<true, number | null, typeof a>()
 })
 
+test('remove optional/undefined when default is provided', () => {
+  interface S {
+    variant?: 'abc' | 'def'
+  }
+  const s: S = {}
+  const [a] = split(s, { variant: 'def' })
+  isType.equal<true, 'abc' | 'def', typeof a.variant>()
+})
+
+test('keep undefined when default is undefined', () => {
+  interface S {
+    variant?: 'abc' | 'def'
+  }
+  const s: S = {}
+  const [a] = split(s, { variant: undefined })
+  isType.equal<true, 'abc' | 'def' | undefined, typeof a.variant>()
+})
+
 
 test('can default with false', () => {
   const s: { a?: number | boolean } = {}

package/ts/object/split.ts

@@ -4,7 +4,7 @@ import { reduceByKey } from './reduceKey'
 
 type Splitter<T extends AnyRecord> = Partial<{ [k in keyof T]: T[k] | undefined }>
 export type Split<T extends AnyRecord, S extends AnyRecord> = {
-  [k in keyof S]: S[k] extends undefined ? T[k] : NonNullable<T[k]> | S[k]
+  [k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | S[k]
 }
 
 /**