@tempots/std 0.9.7 → 0.10.3

package/types/differentiate.d.ts

@@ -1,13 +0,0 @@
-/**
- *
- */
-import { type AnyKey } from './utility';
-import { type ObjectWithField } from './objects';
-import { type Tail } from './tuples';
-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;

package/types/differentiate.js

@@ -1,14 +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.
-*/
-export {};

package/types/functions.d.ts

@@ -1,22 +0,0 @@
-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;
-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;
-export type AnyFunction = Fun | Function;
-export type FirstArgument<F extends AnyFunction> = F extends (a: infer A) => any ? unknown extends A ? never : A : never;
-export type OnlyIfDoesNotReturnNever<F extends Fun> = F extends Fun1<any, never> ? never : F;
-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;
-}[Args extends [] ? 'empty' : Args extends [any] ? 'one' : 'n'];
-export type FunctionsChain<In, Args extends Fun[]> = OnlyIfDoesNotReturnNever<CheckFunctionsChain<In, Args>>;
-export {};

package/types/functions.js

@@ -1,13 +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.
-*/
-export {};

package/types/generic.d.ts

@@ -1,9 +0,0 @@
-/**
- *
- */
-import { type Equals, type NotEquals } from './assert';
-export type Pointer<T> = () => T;
-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;

package/types/generic.js

@@ -1,13 +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.
-*/
-export {};

package/types/objects.d.ts

@@ -1,50 +0,0 @@
-/**
- *
- */
-import { type AnyKey } from './utility';
-import { type Tail } from './tuples';
-import { type AnyFunction } from './functions';
-import { type WhenEquals } from './generic';
-export type ObjectWithField<F extends AnyKey, V> = {
-    [_ in F]: V;
-};
-export type ObjectWithPath<Path extends AnyKey[], V> = Path extends [] ? {} : Path extends [infer T] ? T extends AnyKey ? {
-    [_ in T]: V;
-} : never : 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> = {
-    next: Path extends [infer K, ...any[]] ? K extends AnyKey ? Tail<Path> extends infer Rest ? O extends Record<AnyKey, any> ? Rest extends AnyKey[] ? TypeAtPath<Rest, O[K]> : never : never : never : never : never;
-    empty: O;
-    done: O extends Record<AnyKey, any> ? Path extends [infer K] ? K extends AnyKey ? O[K] : never : never : never;
-}[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];
-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>;

package/types/objects.js

@@ -1,13 +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.
-*/
-export {};

package/types/tuples.d.ts

@@ -1,44 +0,0 @@
-/**
- *
- */
-import { type Pointer, type DeRef } from './generic';
-export type Tail<T extends any[]> = ((...args: T) => void) extends (_: any, ...rest: infer Rest) => void ? Rest : never;
-type DropNImpl<N extends number, T extends any[], I extends any[]> = {
-    return: T;
-    next: DropNImpl<N, Tail<T>, Prepend<any, I>>;
-}[Length<I> extends N ? 'return' : 'next'];
-export type DropN<N extends number, T extends any[]> = DropNImpl<N, T, []>;
-type ReverseImpl<T extends any[], R extends any[], I extends any[]> = {
-    return: DeRef<Pointer<R>>;
-    next: ReverseImpl<T, Prepend<T[Length<I>], R>, Prepend<any, I>>;
-}[Length<I> extends Length<T> ? 'return' : 'next'];
-export type Reverse<T extends any[]> = ReverseImpl<T, [], []>;
-export type Head<T extends any[]> = T extends [infer H, ...any[]] ? H : never;
-export type Last<T extends any[]> = {
-    n: Last<Tail<T>>;
-    one: T extends [infer H] ? H : never;
-    empty: never;
-}[T extends [] ? 'empty' : T extends [any] ? 'one' : 'n'];
-export type TupleToUnion<T extends any[]> = T[number];
-export type Prepend<Insert, Tail extends any[]> = [Insert, ...Tail];
-export type Append<Tuple extends any[], Element> = [...Tuple, Element];
-export type Length<T extends any[]> = T['length'];
-export type LoseLastImpl<A extends any[], B extends any[]> = {
-    empty: A;
-    next: LoseLastImpl<Prepend<B[0], A>, Tail<B>>;
-}[B extends [] ? 'empty' : B extends [any] ? 'empty' : 'next'];
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
-export type Push<T extends any[], V> = [...T, V];
-export type UnionToTuple<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple1<Exclude<T, L>>, L>;
-type UnionToTuple1<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple2<Exclude<T, L>>, L>;
-type UnionToTuple2<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple3<Exclude<T, L>>, L>;
-type UnionToTuple3<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple4<Exclude<T, L>>, L>;
-type UnionToTuple4<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple5<Exclude<T, L>>, L>;
-type UnionToTuple5<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple6<Exclude<T, L>>, L>;
-type UnionToTuple6<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple7<Exclude<T, L>>, L>;
-type UnionToTuple7<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple8<Exclude<T, L>>, L>;
-type UnionToTuple8<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple9<Exclude<T, L>>, L>;
-type UnionToTuple9<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTupleX<Exclude<T, L>>, L>;
-type UnionToTupleX<T> = never;
-export {};

package/types/tuples.js

@@ -1,24 +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.
-*/
-export {};
-// | _Concat_0_0
-// | _Concat_0_1
-// | _Concat_1_0
-// | _Concat_2_3
-// | _Pop_1
-// | _Pop_2
-// | _LoseLast_1
-// | _LoseLast_2
-// | _LoseLast_3
-// | _LoseLast_4

package/types/utility.d.ts

@@ -1,2 +0,0 @@
-export type AnyKey = string | number | symbol;
-export type Primitive = string | boolean | number | null | undefined;

package/types/utility.js

@@ -1 +0,0 @@
-export {};

package/uuid.d.ts

@@ -1,13 +0,0 @@
-/**
- * Helper functions to generate and validate [UUID](http://en.wikipedia.org/wiki/Universally_unique_identifier)
- * strings (version 4).
- */
-import { type Newtype, NewtypeClass } from './newtype';
-/**
- * `Uuid.create()` returns a string value representing a random UUID string.
- */
-export declare function create(): UUID;
-export type UUID = Newtype<string, {
-    readonly UUID: unique symbol;
-}>;
-export declare const UUID: NewtypeClass<UUID>;

package/uuid.js

@@ -1,56 +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.
-*/
-/**
- * Helper functions to generate and validate [UUID](http://en.wikipedia.org/wiki/Universally_unique_identifier)
- * strings (version 4).
- */
-import { NewtypeClass } from './newtype';
-const random = (max) => Math.floor(Math.random() * max);
-const srandom = () => '0123456789abcdef'.charAt(random(0x10));
-/**
- * `Uuid.create()` returns a string value representing a random UUID string.
- */
-export function create() {
-    const s = [];
-    let i = 0;
-    for (i = 0; i < 8; i++)
-        s[i] = srandom();
-    s[8] = '-';
-    for (i = 9; i < 13; i++)
-        s[i] = srandom();
-    s[13] = '-';
-    s[14] = '4';
-    for (i = 15; i < 18; i++)
-        s[i] = srandom();
-    s[18] = '-';
-    s[19] = '89AB'.charAt(random(0x3));
-    for (i = 20; i < 23; i++)
-        s[i] = srandom();
-    s[23] = '-';
-    for (i = 24; i < 36; i++)
-        s[i] = srandom();
-    return UUID.unsafeOf(s.join(''));
-}
-const pattern = /^[0123456789abcdef]{8}-[0123456789abcdef]{4}-4[0123456789abcdef]{3}-[89ab][0123456789abcdef]{3}-[0123456789abcdef]{12}$/i;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const UUID = new (class extends NewtypeClass {
-    /**
-     * Returns `true` if the passed `uuid` conforms to the UUID v.4 format.
-     */
-    isValid(uuid) {
-        return pattern.test(uuid);
-    }
-    toString(uuid) {
-        return UUID.get(uuid);
-    }
-})();

package/validation.d.ts

@@ -1,23 +0,0 @@
-import { Result } from './result';
-export interface Valid {
-    type: 'valid';
-}
-export interface Invalid<E> {
-    type: 'invalid';
-    error: E;
-}
-export type Validation<E> = Valid | Invalid<E>;
-export type PromiseValidation<E> = PromiseLike<Validation<E>>;
-export declare const Validation: {
-    valid: {
-        type: "valid";
-    };
-    invalid<E>(error: E): Validation<E>;
-    isValid<E_1>(r: Validation<E_1>): r is Valid;
-    isInvalid<E_2>(r: Validation<E_2>): r is Invalid<E_2>;
-    cmatch: <V, E_3>(valid: () => V, invalid: (error: E_3) => V) => (r: Validation<E_3>) => V;
-    match: <V_1, E_4>(r: Validation<E_4>, valid: () => V_1, invalid: (error: E_4) => V_1) => V_1;
-    toResult: <T, E_5>(value: T) => (validation: Validation<E_5>) => Result<T, E_5>;
-    whenValid: <E_6>(apply: () => void) => (r: Validation<E_6>) => Validation<E_6>;
-    whenInvalid: <E_7>(apply: (e: E_7) => void) => (r: Validation<E_7>) => Validation<E_7>;
-};

package/validation.js

@@ -1,44 +0,0 @@
-import { Result } from './result';
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const Validation = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    valid: { type: 'valid' },
-    invalid(error) {
-        return { type: 'invalid', error };
-    },
-    isValid(r) {
-        return r.type === 'valid';
-    },
-    isInvalid(r) {
-        return r.type === 'invalid';
-    },
-    cmatch: (valid, invalid) => (r) => {
-        if (Validation.isValid(r)) {
-            return valid();
-        }
-        else {
-            return invalid(r.error);
-        }
-    },
-    match: (r, valid, invalid) => {
-        if (Validation.isValid(r)) {
-            return valid();
-        }
-        else {
-            return invalid(r.error);
-        }
-    },
-    toResult: (value) => Validation.cmatch(() => Result.success(value), (err) => Result.failure(err)),
-    whenValid: (apply) => (r) => {
-        if (Validation.isValid(r)) {
-            apply();
-        }
-        return r;
-    },
-    whenInvalid: (apply) => (r) => {
-        if (Validation.isInvalid(r)) {
-            apply(r.error);
-        }
-        return r;
-    }
-};