@tempots/std 0.9.0

package/src/types/assert.ts

@@ -0,0 +1,96 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ *
+ */
+
+import { type Pointer } from './generic'
+
+export type Assert<A extends true> = A extends never
+  ? 'FAIL'
+  : A extends true
+    ? 'PASS'
+    : 'FAIL'
+export type AssertNot<A extends false> = A extends never
+  ? 'FAIL'
+  : A extends false
+    ? 'PASS'
+    : 'FAIL'
+
+export type Extends<A, B> = A extends B ? true : false
+
+// do not use with `any`
+export type Same<A, B> = Pointer<A> extends Pointer<B>
+  ? Pointer<B> extends Pointer<A>
+    ? true
+    : false
+  : false
+
+export type NotSame<A, B> = Pointer<A> extends Pointer<B>
+  ? Pointer<B> extends Pointer<A>
+    ? false
+    : true
+  : true
+
+// does not work comparing intersection types with literals. Use `Same` for that.
+export type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <
+  T
+>() => T extends B ? 1 : 2
+  ? true
+  : false
+
+export type NotEquals<A, B> = Equals<A, B> extends true ? false : true
+
+export type IsNever<T> = Pointer<T> extends Pointer<never> ? true : false
+
+// TYPE TESTS
+type _primitives_are_not_equals = AssertNot<Equals<number, string>>
+type _primitives_are_not_same = AssertNot<Same<number, string>>
+type _literals_are_equals = Assert<Equals<1, 1>>
+type _literals_are_same = Assert<Same<1, 1>>
+type _literals_are_notsame = Assert<NotSame<1, 2>>
+type _any_is_not_equal_to_literal = Assert<NotEquals<any, 1>>
+type _any_is_equal_to_any = Assert<Equals<any, any>>
+type _union_is_not_equal_to_member = Assert<NotEquals<1 | 2, 1>>
+type _any_is_not_equal_to_never = Assert<NotEquals<any, never>>
+type _any_is_not_same_as_never = Assert<NotEquals<any, never>>
+type _same_tuple_elements_match = Assert<Equals<[number], [number]>>
+type _different_tuple_elements_do_not_match = Assert<NotEquals<[any], [string]>>
+type _intersection_objects_are_same_as_literal = Assert<
+Same<{ x: 1 } & { y: 2 }, { x: 1, y: 2 }>
+>
+type _intersection_objects_not_equal_to_literal = Assert<
+NotEquals<{ x: 1 } & { y: 2 }, { x: 1, y: 2 }>
+>
+type _string_is_not_never = AssertNot<IsNever<string>>
+type _never_is_never = Assert<IsNever<never>>
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _TESTS_ =
+  | _primitives_are_not_equals
+  | _primitives_are_not_same
+  | _literals_are_equals
+  | _literals_are_same
+  | _literals_are_notsame
+  | _any_is_not_equal_to_literal
+  | _any_is_equal_to_any
+  | _union_is_not_equal_to_member
+  | _any_is_not_equal_to_never
+  | _any_is_not_same_as_never
+  | _same_tuple_elements_match
+  | _different_tuple_elements_do_not_match
+  | _intersection_objects_are_same_as_literal
+  | _intersection_objects_not_equal_to_literal
+  | _string_is_not_never
+  | _never_is_never

package/src/types/differentiate.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ *
+ */
+
+import { type AnyKey } from './utility'
+import { type ObjectWithField } from './objects'
+import { type Tail } from './tuples'
+
+// TYPE TESTS
+import { type Assert, type AssertNot, type Equals, type Same } from './assert'
+
+export type Differentiate<
+  Field extends AnyKey,
+  State extends ObjectWithField<Field, any>,
+  ExpectedType extends State[Field]
+> = State extends ObjectWithField<Field, ExpectedType> ? State : never
+
+export type DifferentiateByKind<
+  State extends { kind: any },
+  K extends State['kind']
+> = Differentiate<'kind', State, K>
+
+export type DifferentiateAt<
+  Path extends AnyKey[],
+  State,
+  ExpectedType
+> = Path extends []
+  ? State
+  : Path extends [infer T]
+    ? T extends keyof State
+      ? ExpectedType extends State[T]
+        ? Differentiate<T, State, ExpectedType>
+        : never
+      : never
+    : Path extends [infer K, ...any[]]
+      ? K extends keyof State
+        ? Tail<Path> extends infer Rest
+          ? Rest extends AnyKey[]
+            ? State & { [k in K]: DifferentiateAt<Rest, State[k], ExpectedType> }
+            : never
+          : never
+        : never
+      : never
+
+interface A { kind: 'A', a: string }
+interface B { kind: 'B', b: string }
+type AB = A | B
+
+// DifferentiateByKind
+type T0 = Differentiate<'kind', AB, 'A'>
+
+type _T0_should_only_include_A = Assert<Equals<T0, A>>
+type _T0_should_not_include_B = AssertNot<Equals<T0, B>>
+
+// DifferentiateByKind
+type T1 = DifferentiateByKind<AB, 'A'>
+
+type _T1_should_only_include_A = Assert<Equals<T1, A>>
+type _T1_should_not_include_B = AssertNot<Equals<T1, B>>
+
+// DifferentiateAt
+interface C { ab: AB, c: string }
+type T2 = DifferentiateAt<['ab', 'kind'], C, 'A'>
+
+type _T2_should_only_include_A = Assert<
+Same<T2, { ab: { kind: 'A', a: string }, c: string }>
+>
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _TESTS_ =
+  | _T0_should_only_include_A
+  | _T0_should_not_include_B
+  | _T1_should_only_include_A
+  | _T1_should_not_include_B
+  | _T2_should_only_include_A

package/src/types/functions.ts

@@ -0,0 +1,114 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ *
+ */
+
+// TYPE TESTS
+import { type Assert, type Equals, type Extends, type AssertNot, type IsNever } from './assert'
+import { type Tail } from './tuples'
+
+export type Equality<T> = (a: T, b: T) => boolean
+
+export type Effect<T> = (value: T) => void
+
+export type Proc = () => void
+
+export type Lazy<T> = () => T
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Fun = (...args: any[]) => any
+export type Fun1<A, T> = (a1: A) => T
+export type Fun2<A, B, T> = (a1: A, a2: B) => T
+export type Fun3<A, B, C, T> = (a1: A, a2: B, a3: C) => T
+export type Fun4<A, B, C, D, T> = (a1: A, a2: B, a3: C, a4: D) => T
+export type Fun5<A, B, C, D, E, T> = (a1: A, a2: B, a3: C, a4: D, a5: E) => T
+export type Fun6<A, B, C, D, E, F, T> = (
+  a1: A,
+  a2: B,
+  a3: C,
+  a4: D,
+  a5: E,
+  a6: F
+) => T
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type AnyFunction = Fun | Function
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type FirstArgument<F extends AnyFunction> = F extends (a: infer A) => any
+  ? unknown extends A
+    ? never
+    : A
+  : never
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type OnlyIfDoesNotReturnNever<F extends Fun> = F extends Fun1<any, never>
+  ? never
+  : F
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type CheckFunctionsChain<In, Args extends Array<Fun1<any, any>>> = {
+  empty: (i: In) => In
+  one: FirstArgument<Args[0]> extends In ? Args[0] : never
+  n: FirstArgument<Args[0]> extends In
+    ? (
+        arg: FirstArgument<Args[0]>
+      ) => ReturnType<CheckFunctionsChain<ReturnType<Args[0]>, Tail<Args>>>
+    : never
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+}[Args extends [] ? 'empty' : Args extends [any] ? 'one' : 'n']
+
+export type FunctionsChain<In, Args extends Fun[]> = OnlyIfDoesNotReturnNever<
+CheckFunctionsChain<In, Args>
+>
+type _procedure_is_AnyFunction = Assert<Extends<() => void, AnyFunction>>
+// eslint-disable-next-line @typescript-eslint/ban-types
+type _Function_is_AnyFunction = Assert<Extends<Function, AnyFunction>>
+type _string_is_not_AnyFunction = AssertNot<Extends<string, AnyFunction>>
+
+type _first_argument_matches_type = Assert<
+Equals<FirstArgument<(a: string) => number>, string>
+>
+type _first_argument_does_not_exist = Assert<
+IsNever<FirstArgument<() => number>>
+>
+
+type _chain_matches_first_arg_and_last_return_type = Assert<
+Equals<
+FunctionsChain<
+string,
+[(s: string) => boolean, (b: boolean) => number, (n: number) => Date]
+>,
+Fun1<string, Date>
+>
+>
+
+type _chain_is_never_when_does_not_check_out = Assert<
+IsNever<
+FunctionsChain<
+string,
+[(s: string) => boolean, (b: number) => number, (n: number) => Date]
+>
+>
+>
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _TESTS_ =
+  | _procedure_is_AnyFunction
+  | _Function_is_AnyFunction
+  | _string_is_not_AnyFunction
+  | _first_argument_matches_type
+  | _first_argument_does_not_exist
+  | _chain_matches_first_arg_and_last_return_type
+  | _chain_is_never_when_does_not_check_out

package/src/types/generic.ts

@@ -0,0 +1,42 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ *
+ */
+
+import { type Equals, type NotEquals, type Assert } from './assert'
+
+export type Pointer<T> = () => T
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type DeRef<T extends () => any> = T extends () => infer Ret ? Ret : never
+
+export type WhenEquals<X, Y, A = X, B = never> = Equals<X, Y> extends true
+  ? A
+  : B
+
+export type WhenNotEquals<X, Y, A = X, B = never> = NotEquals<X, Y> extends true
+  ? A
+  : B
+
+export type Cast<A, B> = A extends B ? A : B
+
+type _when_true_returns_A = Assert<
+Equals<WhenEquals<string, string, number, boolean>, number>
+>
+type _when_false_returns_B = Assert<
+Equals<WhenEquals<string, number, number, boolean>, boolean>
+>
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _TESTS_ = _when_true_returns_A | _when_false_returns_B

package/src/types/objects.ts

@@ -0,0 +1,212 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ *
+ */
+
+import { type AnyKey } from './utility'
+import { type Tail } from './tuples'
+import { type AnyFunction } from './functions'
+
+// TYPE TESTS
+import { type Assert, type Equals, type AssertNot } from './assert'
+import { type WhenEquals } from './generic'
+
+export type ObjectWithField<F extends AnyKey, V> = { [_ in F]: V }
+
+export type ObjectWithPath<Path extends AnyKey[], V> = Path extends []
+  ? // eslint-disable-next-line @typescript-eslint/ban-types
+    {}
+  : Path extends [infer T]
+    ? T extends AnyKey
+      ? { [_ in T]: V }
+      : never
+    : // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Path extends [infer K, ...any[]]
+      ? K extends AnyKey
+        ? Tail<Path> extends infer Rest
+          ? Rest extends AnyKey[]
+            ? { [_ in K]: ObjectWithPath<Rest, V> }
+            : never
+          : never
+        : never
+      : never
+
+export type TypeAtPath<Path extends AnyKey[], O> = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  next: Path extends [infer K, ...any[]]
+    ? K extends AnyKey
+      ? Tail<Path> extends infer Rest
+        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        O extends Record<AnyKey, any>
+          ? Rest extends AnyKey[]
+            ? TypeAtPath<Rest, O[K]>
+            : never
+          : never
+        : never
+      : never
+    : never
+  empty: O
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  done: O extends Record<AnyKey, any>
+    ? Path extends [infer K]
+      ? K extends AnyKey
+        ? O[K]
+        : never
+      : never
+    : never
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+}[Path extends [] ? 'empty' : Path extends [any] ? 'done' : 'next']
+
+export type WritableKeys<T> = {
+  [K in keyof T]-?: WhenEquals<
+  { [Q in K]: T[K] },
+  { -readonly [Q in K]: T[K] },
+  K
+  >
+}[keyof T]
+
+export type ReadonlyKeys<T> = {
+  [P in keyof T]-?: WhenEquals<
+  { [Q in P]: T[P] },
+  { -readonly [Q in P]: T[P] },
+  never,
+  P
+  >
+}[keyof T]
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Id<T> = {} & { [P in keyof T]: T[P] }
+
+export type KeysWithFieldType<T, Condition> = {
+  [K in keyof T]: WhenEquals<T[K], Condition, K>
+}[keyof T]
+
+export type KeysWithoutFieldType<T, Condition> = {
+  [K in keyof T]: WhenEquals<T[K], Condition, never, K>
+}[keyof T]
+
+export type RemoveNullableFromFields<T> = {
+  [K in keyof T]: NonNullable<T[K]>
+}
+
+export type WritableFields<T> = Pick<T, WritableKeys<T>>
+export type ReadonlyFields<T> = Pick<T, ReadonlyKeys<T>>
+export type ExcludeFunctionFields<T> = Pick<
+T,
+KeysWithoutFieldType<T, AnyFunction>
+>
+
+export type Merge<A, B> = Id<A & B>
+
+type _merged_ = Merge<{ a: string, c?: number }, { b?: boolean }>
+type _merge_two_object_types_ = Assert<
+Equals<_merged_, { a: string, b?: boolean, c?: number }>
+>
+
+type _object_with_field_has_field = Assert<
+Equals<{ a: number }, ObjectWithField<'a', number>>
+>
+type _object_with_field_has_no_field = AssertNot<
+Equals<{ a: number }, ObjectWithField<'c', number>>
+>
+
+type _object_with_empty_path_is_empty_object = Assert<
+// eslint-disable-next-line @typescript-eslint/ban-types
+Equals<{}, ObjectWithPath<[], number>>
+>
+type _object_with_tuple_of_one_is_object = Assert<
+Equals<{ a: number }, ObjectWithPath<['a'], number>>
+>
+type _object_with_tuple_of_two_is_object = Assert<
+Equals<{ a: { b: number } }, ObjectWithPath<['a', 'b'], number>>
+>
+type _object_with_tuple_of_three_is_object = Assert<
+Equals<{ a: { b: { c: number } } }, ObjectWithPath<['a', 'b', 'c'], number>>
+>
+
+interface _nested { a: { b: boolean[], c: number }, d: string }
+type _type_at_empty_path_is_type_of_argument = Assert<
+Equals<_nested, TypeAtPath<[], _nested>>
+>
+type _type_at_level_1 = Assert<
+Equals<{ b: boolean[], c: number }, TypeAtPath<['a'], _nested>>
+>
+type _type_at_level_2 = Assert<
+Equals<boolean[], TypeAtPath<['a', 'b'], _nested>>
+>
+type _type_at_level_3 = Assert<
+Equals<boolean, TypeAtPath<['a', 'b', number], _nested>>
+>
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type _writable_keys_of_empty_is_never = Assert<Equals<WritableKeys<{}>, never>>
+type _writable_keys_of_writable_is_keys = Assert<
+Equals<WritableKeys<{ a: string, b: string }>, 'a' | 'b'>
+>
+type _writable_keys_of_mixed_is_subset = Assert<
+Equals<WritableKeys<{ a: string, b: string, readonly c: number }>, 'a' | 'b'>
+>
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type _readonly_keys_of_empty_is_never = Assert<Equals<ReadonlyKeys<{}>, never>>
+type _readonly_keys_of_readonly_is_keys = Assert<
+Equals<ReadonlyKeys<{ readonly a: string, readonly b: string }>, 'a' | 'b'>
+>
+type _readonly_keys_of_mixed_is_subset = Assert<
+Equals<
+ReadonlyKeys<{ readonly a: string, readonly b: string, c: number }>,
+'a' | 'b'
+>
+>
+
+type _KeysWithFieldType_matches = Assert<
+Equals<KeysWithFieldType<{ a: string, b: number }, string>, 'a'>
+>
+type _KeysWithoutFieldType_matches = Assert<
+Equals<KeysWithoutFieldType<{ a: string, b: number }, number>, 'a'>
+>
+type _RemoveNullableFromFields_matches = Assert<
+Equals<
+RemoveNullableFromFields<{
+  a: string | null | undefined
+  b: number | null
+  c: boolean
+}>,
+{ a: string, b: number, c: boolean }
+>
+>
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _TESTS_ =
+  | _merge_two_object_types_
+  | _object_with_field_has_field
+  | _object_with_field_has_no_field
+  | _object_with_empty_path_is_empty_object
+  | _object_with_tuple_of_one_is_object
+  | _object_with_tuple_of_two_is_object
+  | _object_with_tuple_of_three_is_object
+  | _type_at_empty_path_is_type_of_argument
+  | _type_at_level_1
+  | _type_at_level_2
+  | _type_at_level_3
+  | _writable_keys_of_empty_is_never
+  | _writable_keys_of_writable_is_keys
+  | _writable_keys_of_mixed_is_subset
+  | _readonly_keys_of_empty_is_never
+  | _readonly_keys_of_readonly_is_keys
+  | _readonly_keys_of_mixed_is_subset
+  | _KeysWithFieldType_matches
+  | _KeysWithoutFieldType_matches
+  | _RemoveNullableFromFields_matches