@duplojs/utils 0.3.1 → 1.0.1

package/dist/common/whenNot.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function whenNot(...args) {
+    if (args.length === 2) {
+        const [ifFunction, theFunction] = args;
+        return (input) => whenNot(input, ifFunction, theFunction);
+    }
+    const [input, ifFunction, theFunction] = args;
+    if (!ifFunction(input)) {
+        return theFunction(input);
+    }
+    return input;
+}
+
+exports.whenNot = whenNot;

package/dist/common/whenNot.d.ts

@@ -0,0 +1,5 @@
+import { type EscapeVoid, type AnyValue } from "./types";
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): (input: GenericInput) => GenericOutput | GenericPredicatedInput;
+export declare function whenNot<GenericInput extends AnyValue, GenericPredicatedInput extends GenericInput, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => input is GenericPredicatedInput, theFunction: (predicatedInput: Exclude<GenericInput, GenericPredicatedInput>) => GenericOutput): GenericOutput | GenericPredicatedInput;
+export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): (input: GenericInput) => GenericOutput | GenericInput;
+export declare function whenNot<GenericInput extends AnyValue, GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, ifFunction: (input: GenericInput) => boolean, theFunction: (predicatedInput: GenericInput) => GenericOutput): GenericOutput | GenericInput;

package/dist/common/whenNot.mjs

@@ -0,0 +1,13 @@
+function whenNot(...args) {
+    if (args.length === 2) {
+        const [ifFunction, theFunction] = args;
+        return (input) => whenNot(input, ifFunction, theFunction);
+    }
+    const [input, ifFunction, theFunction] = args;
+    if (!ifFunction(input)) {
+        return theFunction(input);
+    }
+    return input;
+}
+
+export { whenNot };

package/dist/common/wrapValue.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const keyWrappedValue = "@duplojs/utils/value";
+function wrapValue(value) {
+    return {
+        [keyWrappedValue]: value,
+    };
+}
+function isWrappedValue(input) {
+    return !!input && typeof input === "object" && keyWrappedValue in input;
+}
+
+exports.isWrappedValue = isWrappedValue;
+exports.keyWrappedValue = keyWrappedValue;
+exports.wrapValue = wrapValue;

package/dist/common/wrapValue.d.ts

@@ -0,0 +1,9 @@
+declare const SymbolWrappedValue: unique symbol;
+export type SymbolWrappedValue = typeof SymbolWrappedValue;
+export declare const keyWrappedValue = "@duplojs/utils/value";
+export interface WrappedValue<GenericValue extends unknown = unknown> {
+    [SymbolWrappedValue]: GenericValue;
+}
+export declare function wrapValue<const GenericValue extends unknown>(value: GenericValue): WrappedValue<GenericValue>;
+export declare function isWrappedValue<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, WrappedValue<any>>;
+export {};

package/dist/common/wrapValue.mjs

@@ -0,0 +1,11 @@
+const keyWrappedValue = "@duplojs/utils/value";
+function wrapValue(value) {
+    return {
+        [keyWrappedValue]: value,
+    };
+}
+function isWrappedValue(input) {
+    return !!input && typeof input === "object" && keyWrappedValue in input;
+}
+
+export { isWrappedValue, keyWrappedValue, wrapValue };

package/dist/either/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const eitherInformationKind = kind.createKind("either-information");
+
+exports.eitherInformationKind = eitherInformationKind;

package/dist/either/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherInformationKind: import("../common").KindHandler<import("../common").KindDefinition<"either-information", string>>;

package/dist/either/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../common/kind.mjs';
+
+const eitherInformationKind = createKind("either-information");
+
+export { eitherInformationKind };

package/dist/either/bool/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+
+const eitherBoolKind = kind.createKind("either-bool");
+
+exports.eitherBoolKind = eitherBoolKind;

package/dist/either/bool/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherBoolKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool", unknown>>;

package/dist/either/bool/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../../common/kind.mjs';
+
+const eitherBoolKind = createKind("either-bool");
+
+export { eitherBoolKind };

package/dist/either/bool/create.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var falsy = require('./falsy.cjs');
+var truthy = require('./truthy.cjs');
+
+function bool(value) {
+    return value === undefined
+        || value === null
+        || value === 0
+        || value === ""
+        || value === false
+        ? falsy.boolFalsy(value)
+        : truthy.boolTruthy(value);
+}
+
+exports.bool = bool;

package/dist/either/bool/create.d.ts

@@ -0,0 +1,4 @@
+import { type IsEqual } from "../../common";
+import { type BoolFalsyValue, type EitherBoolFalsy } from "./falsy";
+import { type EitherBoolTruthy } from "./truthy";
+export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends BoolFalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;

package/dist/either/bool/create.mjs

@@ -0,0 +1,14 @@
+import { boolFalsy } from './falsy.mjs';
+import { boolTruthy } from './truthy.mjs';
+
+function bool(value) {
+    return value === undefined
+        || value === null
+        || value === 0
+        || value === ""
+        || value === false
+        ? boolFalsy(value)
+        : boolTruthy(value);
+}
+
+export { bool };

package/dist/either/bool/falsy.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var create = require('../left/create.cjs');
+var is = require('../left/is.cjs');
+var is$1 = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherBoolFalsyKind = kind.createKind("either-bool-falsy");
+function boolFalsy(value = undefined) {
+    return base.eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(create.left("bool", value)));
+}
+function isBoolFalsy(input) {
+    return is.isLeft(input)
+        && base.eitherBoolKind.has(input)
+        && eitherBoolFalsyKind.has(input);
+}
+function whenIsBoolFalsy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolFalsy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isBoolFalsy(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.bool(input);
+    if (isBoolFalsy(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.boolFalsy = boolFalsy;
+exports.eitherBoolFalsyKind = eitherBoolFalsyKind;
+exports.isBoolFalsy = isBoolFalsy;
+exports.whenIsBoolFalsy = whenIsBoolFalsy;

package/dist/either/bool/falsy.d.ts

@@ -0,0 +1,18 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { bool } from "./create";
+import { type Kind } from "../../common/kind";
+import { eitherBoolKind } from "./base";
+export type BoolFalsyValue = 0 | "" | undefined | null | false;
+export declare const eitherBoolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-falsy", unknown>>;
+type _EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> = (EitherLeft<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolFalsyKind.definition>);
+export interface EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> extends _EitherBoolFalsy<GenericValue> {
+}
+export declare function boolFalsy<const GenericValue extends BoolFalsyValue = undefined>(value?: GenericValue): EitherBoolFalsy<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export {};

package/dist/either/bool/falsy.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../../common/kind.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { left } from '../left/create.mjs';
+import { isLeft } from '../left/is.mjs';
+import { isRight } from '../right/is.mjs';
+import { bool } from './create.mjs';
+import { eitherBoolKind } from './base.mjs';
+
+const eitherBoolFalsyKind = createKind("either-bool-falsy");
+function boolFalsy(value = undefined) {
+    return eitherBoolKind.addTo(eitherBoolFalsyKind.addTo(left("bool", value)));
+}
+function isBoolFalsy(input) {
+    return isLeft(input)
+        && eitherBoolKind.has(input)
+        && eitherBoolFalsyKind.has(input);
+}
+function whenIsBoolFalsy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolFalsy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isBoolFalsy(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : bool(input);
+    if (isBoolFalsy(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy };

package/dist/either/bool/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./create";
+export * from "./falsy";
+export * from "./truthy";
+export * from "./base";

package/dist/either/bool/truthy.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var is$1 = require('../left/is.cjs');
+var create = require('../right/create.cjs');
+var is = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
+
+const eitherBoolTruthyKind = kind.createKind("either-bool-truthy");
+function boolTruthy(value) {
+    return base.eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(create.right("bool", value)));
+}
+function isBoolTruthy(input) {
+    return is.isRight(input)
+        && base.eitherBoolKind.has(input)
+        && eitherBoolTruthyKind.has(input);
+}
+function whenIsBoolTruthy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolTruthy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isBoolTruthy(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.bool(input);
+    if (isBoolTruthy(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.boolTruthy = boolTruthy;
+exports.eitherBoolTruthyKind = eitherBoolTruthyKind;
+exports.isBoolTruthy = isBoolTruthy;
+exports.whenIsBoolTruthy = whenIsBoolTruthy;

package/dist/either/bool/truthy.d.ts

@@ -0,0 +1,17 @@
+import { type EitherRight } from "../right";
+import { bool } from "./create";
+import { type EitherLeft } from "../left";
+import { type Kind } from "../../common/kind";
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { eitherBoolKind } from "./base";
+export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-bool-truthy", unknown>>;
+type _EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
+export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extends _EitherBoolTruthy<GenericValue> {
+}
+export declare function boolTruthy<const GenericValue extends unknown>(value: GenericValue): EitherBoolTruthy<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export {};

package/dist/either/bool/truthy.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../../common/kind.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { right } from '../right/create.mjs';
+import { isRight } from '../right/is.mjs';
+import { bool } from './create.mjs';
+import { eitherBoolKind } from './base.mjs';
+
+const eitherBoolTruthyKind = createKind("either-bool-truthy");
+function boolTruthy(value) {
+    return eitherBoolKind.addTo(eitherBoolTruthyKind.addTo(right("bool", value)));
+}
+function isBoolTruthy(input) {
+    return isRight(input)
+        && eitherBoolKind.has(input)
+        && eitherBoolTruthyKind.has(input);
+}
+function whenIsBoolTruthy(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsBoolTruthy(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isBoolTruthy(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : bool(input);
+    if (isBoolTruthy(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy };

package/dist/either/future/base.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+
+const eitherFutureKind = kind.createKind("either-future");
+
+exports.eitherFutureKind = eitherFutureKind;

package/dist/either/future/base.d.ts

@@ -0,0 +1 @@
+export declare const eitherFutureKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-future", unknown>>;

package/dist/either/future/base.mjs

@@ -0,0 +1,5 @@
+import { createKind } from '../../common/kind.mjs';
+
+const eitherFutureKind = createKind("either-future");
+
+export { eitherFutureKind };

package/dist/either/future/create.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+var is$1 = require('../left/is.cjs');
+var success = require('./success.cjs');
+var error = require('./error.cjs');
+var is = require('../right/is.cjs');
+
+const kind = "kind-future-either";
+class Future extends Promise {
+    constructor(value) {
+        super((resolve) => void resolve((value instanceof Promise
+            ? value
+            : Promise.resolve(value))
+            .then((value) => {
+            if (is.isRight(value)) {
+                return value;
+            }
+            else if (is$1.isLeft(value)) {
+                return value;
+            }
+            else {
+                return success.futureSuccess(value);
+            }
+        })
+            .catch((error$1) => error.futureError(error$1))));
+    }
+    [kind] = null;
+    // @ts-expect-error override signature error
+    then(theFunction) {
+        return new Future(super.then(theFunction));
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "Future"
+            && kind in value;
+    }
+    static all(values) {
+        return new Future(Promise.all(values.map((value) => new Future(value))));
+    }
+}
+function future(value) {
+    return new Future(value);
+}
+
+exports.Future = Future;
+exports.future = future;

package/dist/either/future/create.d.ts

@@ -0,0 +1,25 @@
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { type EitherFutureSuccess } from "./success";
+import { type EitherFutureError } from "./error";
+import { type IsEqual } from "../../common/types/isEqual";
+import { type MaybePromise } from "../../common/types/maybePromise";
+import { type AnyValue } from "../../common";
+type Either = EitherRight | EitherLeft;
+type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? EitherFutureSuccess<Exclude<GenericValue, Either>> : never;
+type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Promise<unknown> ? EitherFutureError : never;
+type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>;
+export type FutureEitherAllResult<GenericArray extends readonly unknown[] | []> = Future<{
+    -readonly [Prop in keyof GenericArray]: Awaited<Future<GenericArray[Prop]>>;
+}>;
+declare const kind = "kind-future-either";
+export declare class Future<const GenericValue extends unknown = unknown> extends Promise<ComputeFutureEitherResult<GenericValue>> {
+    constructor(value: GenericValue);
+    [kind]: unknown;
+    then<const GenericOutput extends AnyValue>(theFunction: (result: Extract<ComputeFutureEitherResult<GenericValue>, any>) => MaybePromise<GenericOutput>): Future<GenericOutput>;
+    static get [Symbol.species](): PromiseConstructor;
+    static instanceof<GenericValue extends unknown>(value: GenericValue): value is Extract<GenericValue, Future<any>>;
+    static all<const GenericValue extends unknown, GenericArray extends readonly GenericValue[] | []>(values: GenericArray): FutureEitherAllResult<GenericArray>;
+}
+export declare function future<const GenericEither extends unknown>(value: GenericEither): Future<GenericEither>;
+export {};

package/dist/either/future/create.mjs

@@ -0,0 +1,46 @@
+import { isLeft } from '../left/is.mjs';
+import { futureSuccess } from './success.mjs';
+import { futureError } from './error.mjs';
+import { isRight } from '../right/is.mjs';
+
+const kind = "kind-future-either";
+class Future extends Promise {
+    constructor(value) {
+        super((resolve) => void resolve((value instanceof Promise
+            ? value
+            : Promise.resolve(value))
+            .then((value) => {
+            if (isRight(value)) {
+                return value;
+            }
+            else if (isLeft(value)) {
+                return value;
+            }
+            else {
+                return futureSuccess(value);
+            }
+        })
+            .catch((error) => futureError(error))));
+    }
+    [kind] = null;
+    // @ts-expect-error override signature error
+    then(theFunction) {
+        return new Future(super.then(theFunction));
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    static instanceof(value) {
+        return typeof value === "object"
+            && value?.constructor?.name === "Future"
+            && kind in value;
+    }
+    static all(values) {
+        return new Future(Promise.all(values.map((value) => new Future(value))));
+    }
+}
+function future(value) {
+    return new Future(value);
+}
+
+export { Future, future };

package/dist/either/future/error.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var create = require('../left/create.cjs');
+var base = require('./base.cjs');
+
+const eitherFutureErrorKind = kind.createKind("either-future-error");
+function futureError(value) {
+    return base.eitherFutureKind.addTo(eitherFutureErrorKind.addTo(create.left("future", value)));
+}
+
+exports.eitherFutureErrorKind = eitherFutureErrorKind;
+exports.futureError = futureError;

package/dist/either/future/error.d.ts

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { eitherFutureKind } from "./base";
+export declare const eitherFutureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-future-error", unknown>>;
+type _EitherFutureError = (EitherLeft<"future", unknown> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureErrorKind.definition>);
+export interface EitherFutureError extends _EitherFutureError {
+}
+export declare function futureError(value: unknown): EitherFutureError;
+export {};

package/dist/either/future/error.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { left } from '../left/create.mjs';
+import { eitherFutureKind } from './base.mjs';
+
+const eitherFutureErrorKind = createKind("either-future-error");
+function futureError(value) {
+    return eitherFutureKind.addTo(eitherFutureErrorKind.addTo(left("future", value)));
+}
+
+export { eitherFutureErrorKind, futureError };

package/dist/either/future/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./create";
+export * from "./error";
+export * from "./success";
+export * from "./base";
+export * from "./maybeFutureEither";

package/dist/either/future/maybeFutureEither.d.ts

@@ -0,0 +1,2 @@
+import { type Future } from "./create";
+export type MaybeFutureEither<GenericValue extends unknown> = Future<GenericValue> | GenericValue;

package/dist/either/future/success.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var base = require('./base.cjs');
+var create = require('../right/create.cjs');
+
+const eitherFutureSuccessKind = kind.createKind("either-future-success");
+function futureSuccess(value) {
+    return base.eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(create.right("future", value)));
+}
+
+exports.eitherFutureSuccessKind = eitherFutureSuccessKind;
+exports.futureSuccess = futureSuccess;

package/dist/either/future/success.d.ts

@@ -0,0 +1,9 @@
+import { type EitherRight } from "../right";
+import { type Kind } from "../../common/kind";
+import { eitherFutureKind } from "./base";
+export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-future-success", unknown>>;
+type _EitherFutureSuccess<GenericValue extends unknown = unknown> = (EitherRight<"future", GenericValue> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureSuccessKind.definition>);
+export interface EitherFutureSuccess<GenericValue extends unknown = unknown> extends _EitherFutureSuccess<GenericValue> {
+}
+export declare function futureSuccess<const GenericValue extends unknown>(value: GenericValue): EitherFutureSuccess<GenericValue>;
+export {};

package/dist/either/future/success.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { eitherFutureKind } from './base.mjs';
+import { right } from '../right/create.mjs';
+
+const eitherFutureSuccessKind = createKind("either-future-success");
+function futureSuccess(value) {
+    return eitherFutureKind.addTo(eitherFutureSuccessKind.addTo(right("future", value)));
+}
+
+export { eitherFutureSuccessKind, futureSuccess };

package/dist/either/hasInformation.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var base = require('./base.cjs');
+
+function hasInformation(input, information) {
+    return base.eitherInformationKind.has(input)
+        && base.eitherInformationKind.getValue(input) === information;
+}
+
+exports.hasInformation = hasInformation;

package/dist/either/hasInformation.d.ts

@@ -0,0 +1,7 @@
+import { type Kind } from "../common";
+import { type EitherLeft } from "./left";
+import { type EitherRight } from "./right";
+import { eitherInformationKind } from "./base";
+type Either = EitherRight | EitherLeft;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export {};

package/dist/either/hasInformation.mjs

@@ -0,0 +1,8 @@
+import { eitherInformationKind } from './base.mjs';
+
+function hasInformation(input, information) {
+    return eitherInformationKind.has(input)
+        && eitherInformationKind.getValue(input) === information;
+}
+
+export { hasInformation };