@tempots/std 0.9.6 → 0.9.7

package/src/types/assert.ts

@@ -1,96 +0,0 @@
-/*
-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

@@ -1,89 +0,0 @@
-/* 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

@@ -1,114 +0,0 @@
-/*
-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

@@ -1,42 +0,0 @@
-/*
-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

@@ -1,212 +0,0 @@
-/*
-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