functype 0.8.47 → 0.8.49

package/dist/valuable/Valuable.d.mts

@@ -1,6 +0,0 @@
-declare function Valuable<T>(value: T): {
-    value: T;
-};
-type Valuable<T> = ReturnType<typeof Valuable<T>>;
-
-export { Valuable };

package/dist/valuable/Valuable.d.ts

@@ -1,6 +0,0 @@
-declare function Valuable<T>(value: T): {
-    value: T;
-};
-type Valuable<T> = ReturnType<typeof Valuable<T>>;
-
-export { Valuable };

package/dist/valuable/Valuable.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});function t(e){return{value:e}}exports.Valuable = t;

package/dist/valuable/Valuable.mjs

@@ -1 +0,0 @@
-function t(e){return{value:e}}export{t as Valuable};

package/lib/TaskPromise.d.ts

@@ -1,3 +0,0 @@
-import { Type } from "../lib";
-import { Functor } from "./functor";
-export type TaskPromise<A extends Type> = Promise<A> & Functor<A>;

package/lib/collections/index.d.ts

@@ -1,8 +0,0 @@
-import { List } from "../list/List";
-import { Set } from "../set/Set";
-export type Converters<A> = {
-    toList(): List<A>;
-    toSet(): Set<A>;
-    toString(): string;
-};
-export type Collection<A> = Converters<A>;

package/lib/either/Either.d.ts

@@ -1,52 +0,0 @@
-import { Functor, Type } from "../functor";
-import { List } from "../list/List";
-import { Option } from "../option/Option";
-import { Typeable } from "../typeable/Typeable";
-export type Either<L extends Type, R extends Type> = {
-    readonly _tag: "Left" | "Right";
-    value: L | R;
-    isLeft: () => boolean;
-    isRight: () => boolean;
-    getOrElse: (defaultValue: R) => R;
-    getOrThrow: () => R;
-    map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
-    merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
-    mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
-    flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
-    flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
-    toOption: () => Option<R>;
-    toList: () => List<R>;
-    toString: () => string;
-    [Symbol.iterator]: () => Iterator<R>;
-    yield: () => Generator<R, void, unknown>;
-    traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>;
-    lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>;
-    tap: (f: (value: R) => void) => Either<L, R>;
-    tapLeft: (f: (value: L) => void) => Either<L, R>;
-    mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>;
-    bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>;
-    fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T;
-    swap: () => Either<R, L>;
-} & Typeable<"Left" | "Right"> & PromiseLike<R>;
-export type TestEither<L extends Type, R extends Type> = Either<L, R> & Functor<R>;
-export declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
-export declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
-export declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-    value: R;
-};
-export declare const isLeft: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
-    value: L;
-};
-export declare const tryCatch: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
-export declare const TypeCheckRight: <L extends Type, R extends Type>(value: R) => TestEither<L, R>;
-export declare const TypeCheckLeft: <L extends Type, R extends Type>(value: L) => TestEither<L, R>;
-export declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R>, onError: (error: unknown) => L) => Promise<Either<L, R>>;
-export declare const tryCatchSync: <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
-export declare const Either: {
-    sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
-    traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
-    fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L) => Either<L, R>;
-    fromPredicate: <L extends Type, R extends Type>(value: R, predicate: (value: R) => boolean, leftValue: L) => Either<L, R>;
-    ap: <L extends Type, R extends Type, U extends Type>(eitherF: Either<L, (value: R) => U>, eitherV: Either<L, R>) => Either<L, U>;
-    fromPromise: <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L) => Promise<Either<L, R>>;
-};

package/lib/either/EitherT.d.ts

@@ -1,9 +0,0 @@
-import { Either } from "./Either";
-export type EitherT<L, R> = {
-    value: Promise<Either<L, R>>;
-    map<U>(f: (value: R) => U): EitherT<L, U>;
-    flatMap<U>(f: (value: R) => EitherT<L, U>): EitherT<L, U>;
-    mapLeft<U>(f: (value: L) => U): EitherT<U, R>;
-    fold<U>(onLeft: (error: L) => U, onRight: (value: R) => U): Promise<U>;
-};
-export declare function EitherT<L, R>(value: Promise<Either<L, R>>): EitherT<L, R>;

package/lib/error/ParseError.d.ts

@@ -1,6 +0,0 @@
-export declare const ParseError: (message?: string) => Error & {
-    name: "ParseError";
-};
-export type ParseError = Error & {
-    name: "ParseError";
-};

package/lib/functor/index.d.ts

@@ -1,15 +0,0 @@
-export type SingleType = unknown;
-export type ArrayType = SingleType[];
-export type Type = SingleType | ArrayType;
-export type AbstractFunctor<A extends Type> = {
-    map(f: (value: A) => Type): AbstractFunctor<Type>;
-    flatMap(f: (value: A) => AbstractFunctor<Type>): AbstractFunctor<Type>;
-};
-export type Functor<A extends Type> = AbstractFunctor<A> & {
-    map<B extends Type>(f: (value: A) => B): Functor<B>;
-    flatMap<B extends Type>(f: (value: A) => Functor<B>): Functor<B>;
-};
-export type ArrayFunctor<A extends ArrayType> = AbstractFunctor<A> & {
-    map<U extends ArrayType>(f: (value: A) => U): ArrayFunctor<U>;
-    flatMap<U extends ArrayType>(f: (value: A) => ArrayFunctor<U>): ArrayFunctor<U>;
-};

package/lib/identity/Identity.d.ts

@@ -1,4 +0,0 @@
-export type Identity<T> = {
-    id: T;
-    isSame?: (other: Identity<T>) => boolean;
-};

package/lib/index.d.ts

@@ -1,21 +0,0 @@
-import { Functor, Type } from "./functor";
-export type Traversable<A extends Type> = Functor<A> & {
-    get size(): number;
-    get isEmpty(): boolean;
-    contains(value: A): boolean;
-    reduce(f: (b: A, a: A) => A): A;
-    reduceRight(f: (b: A, a: A) => A): A;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-};
-export * from "./either/Either";
-export * from "./functor";
-export * from "./identity/Identity";
-export * from "./iterable";
-export * from "./list/List";
-export * from "./map/Map";
-export * from "./option/Option";
-export * from "./set/Set";
-export * from "./try/Try";
-export * from "./tuple/Tuple";
-export * from "./typeable/Typeable";

package/lib/iterable/Seq.d.ts

@@ -1,31 +0,0 @@
-import { Option } from "../option/Option";
-import { Typeable } from "../typeable/Typeable";
-import { _Iterable_ } from "./index";
-export type Seq<A> = {
-    readonly length: number;
-    readonly [Symbol.iterator]: () => Iterator<A>;
-    map: <B>(f: (a: A) => B) => Seq<B>;
-    flatMap: <B>(f: (a: A) => _Iterable_<B>) => Seq<B>;
-    forEach: (f: (a: A) => void) => void;
-    count: (p: (x: A) => boolean) => number;
-    exists: (p: (a: A) => boolean) => boolean;
-    filter: (p: (a: A) => boolean) => Seq<A>;
-    filterNot: (p: (a: A) => boolean) => Seq<A>;
-    find: (p: (a: A) => boolean) => Option<A>;
-    readonly head: A;
-    readonly headOption: Option<A>;
-    readonly isEmpty: boolean;
-    readonly size: number;
-    toArray: () => A[];
-    reduce: (f: (prev: A, curr: A) => A) => A;
-    reduceRight: (f: (prev: A, curr: A) => A) => A;
-    foldLeft: <B>(z: B) => (op: (b: B, a: A) => B) => B;
-    foldRight: <B>(z: B) => (op: (a: A, b: B) => B) => B;
-    toString: () => string;
-    toValue: () => {
-        _tag: string;
-        value: A[];
-    };
-} & _Iterable_<A> & Typeable<"Seq">;
-export declare const createSeq: <A>(values?: Iterable<A> | _Iterable_<A>) => Seq<A>;
-export declare const Seq: <A>(values?: Iterable<A> | _Iterable_<A>) => Seq<A>;

package/lib/iterable/index.d.ts

@@ -1,22 +0,0 @@
-import { Functor, Type } from "../functor";
-import { Option } from "../option/Option";
-export type _Iterable_<A extends Type> = {
-    count(p: (x: A) => boolean): number;
-    find(p: (a: A) => boolean): Option<A>;
-    forEach(f: (a: A) => void): void;
-    exists(p: (a: A) => boolean): boolean;
-    filter(p: (a: A) => boolean): _Iterable_<A>;
-    filterNot(p: (a: A) => boolean): _Iterable_<A>;
-    reduce(f: (b: A, a: A) => A): A;
-    reduceRight(f: (b: A, a: A) => A): A;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-    get head(): A;
-    get headOption(): Option<A>;
-    get isEmpty(): boolean;
-    map<B extends Type>(f: (a: A) => B): _Iterable_<B>;
-    flatMap<B extends Type>(f: (a: A) => _Iterable_<B> | Iterable<B>): _Iterable_<B>;
-    get size(): number;
-    toArray(): readonly A[];
-} & Functor<A>;
-export { Seq } from "./Seq";

package/lib/list/List.d.ts

@@ -1,26 +0,0 @@
-import { Collection } from "../collections";
-import { _Iterable_, Seq } from "../iterable";
-import { Option } from "../option/Option";
-import { Set } from "../set/Set";
-import { Typeable } from "../typeable/Typeable";
-export type List<A> = {
-    add: (item: A) => List<A>;
-    map: <B>(f: (a: A) => B) => List<B>;
-    flatMap: <B>(f: (a: A) => _Iterable_<B>) => List<B>;
-    remove: (value: A) => List<A>;
-    contains: (value: A) => boolean;
-    removeAt: (index: number) => List<A>;
-    get: (index: number) => Option<A>;
-    concat: (other: List<A>) => List<A>;
-    toList: () => List<A>;
-    toSet: () => Set<A>;
-    toString: () => string;
-    toValue: () => {
-        _tag: string;
-        value: A[];
-    };
-} & Seq<A> & Typeable<"List">;
-type InternalList<A> = List<A> & ArrayLike<A> & _Iterable_<A> & Collection<A>;
-export declare const List: <A>(values?: Iterable<A> | _Iterable_<A>) => List<A>;
-export declare const TestList: <A>(values?: Iterable<A> | _Iterable_<A>) => InternalList<A>;
-export {};

package/lib/map/Map.d.ts

@@ -1,17 +0,0 @@
-import { Collection } from "../collections";
-import { Traversable } from "../index";
-import { _Iterable_ } from "../iterable";
-import { Option } from "../option/Option";
-import { Tuple } from "../tuple/Tuple";
-type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap">;
-export type Map<K, V> = {
-    add(item: Tuple<[K, V]>): Map<K, V>;
-    remove(value: K): Map<K, V>;
-    map<U>(f: (value: V) => U): Map<K, U>;
-    flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => _Iterable_<[K2, V2]>): Map<K2, V2>;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    orElse(key: K, alternative: Option<V>): Option<V>;
-} & SafeTraversable<K, V> & Collection<Tuple<[K, V]>>;
-export declare const Map: <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map<K, V>;
-export {};

package/lib/map/shim.d.ts

@@ -1,2 +0,0 @@
-export type IESMap<K, V> = Map<K, V>;
-export declare const ESMap: MapConstructor;

package/lib/option/Option.d.ts

@@ -1,30 +0,0 @@
-import { Functor, Type } from "../functor";
-import { Either, List, Traversable } from "../index";
-import { Typeable } from "../typeable/Typeable";
-export type Option<T extends Type> = {
-    readonly _tag: "Some" | "None";
-    readonly value: T | undefined;
-    isEmpty: boolean;
-    get(): T;
-    getOrElse(defaultValue: T): T;
-    orElse(alternative: Option<T>): Option<T>;
-    map<U extends Type>(f: (value: T) => U): Option<U>;
-    filter(predicate: (value: T) => boolean): Option<T>;
-    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
-    reduce<U>(f: (acc: U, value: T) => U): U;
-    reduceRight<U>(f: (acc: U, value: T) => U): U;
-    foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
-    foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
-    toList(): List<T>;
-    contains(value: T): boolean;
-    size: number;
-    toEither<E>(left: E): Either<E, T>;
-    toString(): string;
-    toValue(): {
-        _tag: "Some" | "None";
-        value: T;
-    };
-} & (Traversable<T> & Functor<T> & Typeable<"Some" | "None">);
-export declare const Some: <T extends Type>(value: T) => Option<T>;
-export declare const None: <T extends Type>() => Option<T>;
-export declare const Option: <T extends Type>(value: T | null | undefined) => Option<T>;

package/lib/serializable/Serializable.d.ts

@@ -1,15 +0,0 @@
-export type SerializableTypes = "json" | "yaml";
-type SerializationMethods<T> = {
-    json: {
-        toJSON(): string;
-        fromJSON(json: string): T;
-    };
-    yaml: {
-        toYAML(): string;
-        fromYAML(yaml: string): T;
-    };
-};
-export type Serializable<STypes extends SerializableTypes[], T> = T & (STypes extends [] ? NonNullable<unknown> : STypes extends [infer First, ...infer Rest] ? First extends keyof SerializationMethods<T> ? SerializationMethods<T>[First] & Serializable<Rest extends SerializableTypes[] ? Rest : [], T> : never : never);
-export type SupportedSerializationTypes<T> = T extends Serializable<infer Types, never> ? Types : never;
-export declare function createSerializable<STypes extends SerializableTypes[], T>(obj: T, serializationMethods: Pick<SerializationMethods<T>, STypes[number]>): Serializable<STypes, T>;
-export {};

package/lib/set/Set.d.ts

@@ -1,15 +0,0 @@
-import { Collection } from "../collections";
-import { _Iterable_ } from "../iterable";
-import { List } from "../list/List";
-export type Set<A> = {
-    add: (value: A) => Set<A>;
-    remove: (value: A) => Set<A>;
-    contains: (value: A) => boolean;
-    has: (value: A) => boolean;
-    map: <B>(f: (a: A) => B) => Set<B>;
-    flatMap: <B>(f: (a: A) => _Iterable_<B>) => Set<B>;
-    toList: () => List<A>;
-    toSet: () => Set<A>;
-    toString: () => string;
-} & _Iterable_<A> & Collection<A>;
-export declare const Set: <A>(iterable?: Iterable<A> | _Iterable_<A>) => Set<A>;

package/lib/set/shim.d.ts

@@ -1,2 +0,0 @@
-export type IESSet<T> = Set<T>;
-export declare const ESSet: SetConstructor;

package/lib/try/Try.d.ts

@@ -1,18 +0,0 @@
-import { Either } from "../either/Either";
-import { Typeable } from "../typeable/Typeable";
-export type Try<T> = {
-    readonly _tag: "Success" | "Failure";
-    readonly value: T | undefined;
-    readonly error: Error | undefined;
-    isSuccess: () => boolean;
-    isFailure: () => boolean;
-    get: () => T;
-    getOrElse: (defaultValue: T) => T;
-    orElse: (alternative: Try<T>) => Try<T>;
-    orThrow: (error: Error) => T;
-    toEither: () => Either<Error, T>;
-    map: <U>(f: (value: T) => U) => Try<U>;
-    flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
-    toString: () => string;
-} & Typeable<"Success" | "Failure">;
-export declare const Try: <T>(f: () => T) => Try<T>;

package/lib/tuple/Tuple.d.ts

@@ -1,9 +0,0 @@
-import { ArrayFunctor, ArrayType } from "../functor";
-export type Tuple<T extends ArrayType> = {
-    get<K extends number>(index: K): T[K];
-    map<U extends ArrayType>(f: (value: T) => U): Tuple<U>;
-    flatMap<U extends ArrayType>(f: (value: T) => Tuple<U>): Tuple<U>;
-    toArray(): T;
-    [Symbol.iterator](): Iterator<T[number]>;
-} & ArrayFunctor<T>;
-export declare const Tuple: <T extends ArrayType>(values: T) => Tuple<T>;

package/lib/typeable/Typeable.d.ts

@@ -1,4 +0,0 @@
-export declare function Typeable(type: string): {
-    readonly _tag: string;
-};
-export type Typeable<T extends string> = ReturnType<typeof Typeable>;

package/lib/util/index.d.ts

@@ -1,3 +0,0 @@
-import { Either } from "../either/Either";
-import { ParseError } from "../error/ParseError";
-export declare const parseNumber: (input: string) => Either<ParseError, number>;

package/lib/util/isIterable.d.ts

@@ -1 +0,0 @@
-export declare const isIterable: <T>(value: unknown) => value is Iterable<T>;