@duplojs/utils 0.3.1 → 1.0.1

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

@@ -0,0 +1,3 @@
+import { type EitherNullishEmpty, type NullishValue } from "./empty";
+import { type EitherNullishFilled } from "./filled";
+export declare function nullish<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends NullishValue ? EitherNullishEmpty<GenericValue> : EitherNullishFilled<GenericValue>;

package/dist/either/nullish/create.mjs

@@ -0,0 +1,10 @@
+import { nullishEmpty } from './empty.mjs';
+import { nullishFilled } from './filled.mjs';
+
+function nullish(value) {
+    return value === null || value === undefined
+        ? nullishEmpty(value)
+        : nullishFilled(value);
+}
+
+export { nullish };

package/dist/either/nullish/empty.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 eitherNullishEmptyKind = kind.createKind("either-nullish-empty");
+function nullishEmpty(value = undefined) {
+    return base.eitherNullishKind.addTo(eitherNullishEmptyKind.addTo(create.left("nullish", value)));
+}
+function isNullishEmpty(input) {
+    return is.isLeft(input)
+        && base.eitherNullishKind.has(input)
+        && eitherNullishEmptyKind.has(input);
+}
+function whenIsNullishEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullishEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isNullishEmpty(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.nullish(input);
+    if (isNullishEmpty(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherNullishEmptyKind = eitherNullishEmptyKind;
+exports.isNullishEmpty = isNullishEmpty;
+exports.nullishEmpty = nullishEmpty;
+exports.whenIsNullishEmpty = whenIsNullishEmpty;

package/dist/either/nullish/empty.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 { nullish } from "./create";
+import { type Kind } from "../../common/kind";
+import { eitherNullishKind } from "./base";
+export type NullishValue = null | undefined;
+export declare const eitherNullishEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullish-empty", unknown>>;
+type _EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = (EitherLeft<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishEmptyKind.definition>);
+export interface EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> extends _EitherNullishEmpty<GenericValue> {
+}
+export declare function nullishEmpty<const GenericValue extends NullishValue = undefined>(value?: GenericValue): EitherNullishEmpty<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isNullishEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishEmpty>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export declare function whenIsNullishEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishEmpty>;
+export {};

package/dist/either/nullish/empty.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 { nullish } from './create.mjs';
+import { eitherNullishKind } from './base.mjs';
+
+const eitherNullishEmptyKind = createKind("either-nullish-empty");
+function nullishEmpty(value = undefined) {
+    return eitherNullishKind.addTo(eitherNullishEmptyKind.addTo(left("nullish", value)));
+}
+function isNullishEmpty(input) {
+    return isLeft(input)
+        && eitherNullishKind.has(input)
+        && eitherNullishEmptyKind.has(input);
+}
+function whenIsNullishEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullishEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isNullishEmpty(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : nullish(input);
+    if (isNullishEmpty(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, whenIsNullishEmpty };

package/dist/either/nullish/filled.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 eitherNullishFilledKind = kind.createKind("either-nullish-filled");
+function nullishFilled(value) {
+    return base.eitherNullishKind.addTo(eitherNullishFilledKind.addTo(create.right("nullish", value)));
+}
+function isNullishFilled(input) {
+    return is.isRight(input)
+        && base.eitherNullishKind.has(input)
+        && base.eitherNullishKind.has(input);
+}
+function whenIsNullishFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullishFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isNullishFilled(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.nullish(input);
+    if (isNullishFilled(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherNullishFilledKind = eitherNullishFilledKind;
+exports.isNullishFilled = isNullishFilled;
+exports.nullishFilled = nullishFilled;
+exports.whenIsNullishFilled = whenIsNullishFilled;

package/dist/either/nullish/filled.d.ts

@@ -0,0 +1,17 @@
+import { type EitherRight } from "../right";
+import { type EitherLeft } from "../left";
+import { nullish } from "./create";
+import { type Kind } from "../../common/kind";
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { eitherNullishKind } from "./base";
+export declare const eitherNullishFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullish-filled", unknown>>;
+type _EitherNullishFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishFilledKind.definition>);
+export interface EitherNullishFilled<GenericValue extends unknown = unknown> extends _EitherNullishFilled<GenericValue> {
+}
+export declare function nullishFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullishFilled<GenericValue>;
+type Either = EitherRight | EitherLeft;
+export declare function isNullishFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullishFilled>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullish<GenericValue>>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export declare function whenIsNullishFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullishFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullishFilled>;
+export {};

package/dist/either/nullish/filled.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 { nullish } from './create.mjs';
+import { eitherNullishKind } from './base.mjs';
+
+const eitherNullishFilledKind = createKind("either-nullish-filled");
+function nullishFilled(value) {
+    return eitherNullishKind.addTo(eitherNullishFilledKind.addTo(right("nullish", value)));
+}
+function isNullishFilled(input) {
+    return isRight(input)
+        && eitherNullishKind.has(input)
+        && eitherNullishKind.has(input);
+}
+function whenIsNullishFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullishFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isNullishFilled(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : nullish(input);
+    if (isNullishFilled(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherNullishFilledKind, isNullishFilled, nullishFilled, whenIsNullishFilled };

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

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

package/dist/either/optional/base.cjs

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

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

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

package/dist/either/optional/base.mjs

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

package/dist/either/optional/create.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var empty = require('./empty.cjs');
+var filled = require('./filled.cjs');
+
+function optional(value) {
+    return value === undefined
+        ? empty.optionalEmpty()
+        : filled.optionalFilled(value);
+}
+
+exports.optional = optional;

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

@@ -0,0 +1,3 @@
+import { type EitherOptionalEmpty } from "./empty";
+import { type EitherOptionalFilled } from "./filled";
+export declare function optional<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends undefined ? EitherOptionalEmpty : EitherOptionalFilled<GenericValue>;

package/dist/either/optional/create.mjs

@@ -0,0 +1,10 @@
+import { optionalEmpty } from './empty.mjs';
+import { optionalFilled } from './filled.mjs';
+
+function optional(value) {
+    return value === undefined
+        ? optionalEmpty()
+        : optionalFilled(value);
+}
+
+export { optional };

package/dist/either/optional/empty.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var kind = require('../../common/kind.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 eitherOptionalEmptyKind = kind.createKind("either-optional-empty");
+function optionalEmpty() {
+    return base.eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(create.left("optional", undefined)));
+}
+function isOptionalEmpty(input) {
+    return is.isLeft(input)
+        && base.eitherOptionalKind.has(input)
+        && eitherOptionalEmptyKind.has(input);
+}
+function whenIsOptionalEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isOptionalEmpty(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.optional(input);
+    if (isOptionalEmpty(either)) {
+        return theFunction(undefined);
+    }
+    return either;
+}
+
+exports.eitherOptionalEmptyKind = eitherOptionalEmptyKind;
+exports.isOptionalEmpty = isOptionalEmpty;
+exports.optionalEmpty = optionalEmpty;
+exports.whenIsOptionalEmpty = whenIsOptionalEmpty;

package/dist/either/optional/empty.d.ts

@@ -0,0 +1,17 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { optional } from "./create";
+import { eitherOptionalKind } from "./base";
+export declare const eitherOptionalEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional-empty", unknown>>;
+type _EitherOptionalEmpty = (EitherLeft<"optional", undefined> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalEmptyKind.definition>);
+export interface EitherOptionalEmpty extends _EitherOptionalEmpty {
+}
+type Either = EitherRight | EitherLeft;
+export declare function optionalEmpty(): EitherOptionalEmpty;
+export declare function isOptionalEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalEmpty>;
+type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export declare function whenIsOptionalEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalEmpty>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalEmpty>;
+export {};

package/dist/either/optional/empty.mjs

@@ -0,0 +1,38 @@
+import { createKind } from '../../common/kind.mjs';
+import { left } from '../left/create.mjs';
+import { isLeft } from '../left/is.mjs';
+import { isRight } from '../right/is.mjs';
+import { optional } from './create.mjs';
+import { eitherOptionalKind } from './base.mjs';
+
+const eitherOptionalEmptyKind = createKind("either-optional-empty");
+function optionalEmpty() {
+    return eitherOptionalKind.addTo(eitherOptionalEmptyKind.addTo(left("optional", undefined)));
+}
+function isOptionalEmpty(input) {
+    return isLeft(input)
+        && eitherOptionalKind.has(input)
+        && eitherOptionalEmptyKind.has(input);
+}
+function whenIsOptionalEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isOptionalEmpty(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : optional(input);
+    if (isOptionalEmpty(either)) {
+        return theFunction(undefined);
+    }
+    return either;
+}
+
+export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, whenIsOptionalEmpty };

package/dist/either/optional/filled.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 eitherOptionalFilledKind = kind.createKind("either-optional-filled");
+function optionalFilled(value) {
+    return base.eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(create.right("optional", value)));
+}
+function isOptionalFilled(input) {
+    return is.isRight(input)
+        && base.eitherOptionalKind.has(input)
+        && eitherOptionalFilledKind.has(input);
+}
+function whenIsOptionalFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isLeft(input)) {
+        return input;
+    }
+    else if (!isOptionalFilled(input) && is.isRight(input)) {
+        return input;
+    }
+    const either = is.isRight(input) || is$1.isLeft(input)
+        ? input
+        : create$1.optional(input);
+    if (isOptionalFilled(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherOptionalFilledKind = eitherOptionalFilledKind;
+exports.isOptionalFilled = isOptionalFilled;
+exports.optionalFilled = optionalFilled;
+exports.whenIsOptionalFilled = whenIsOptionalFilled;

package/dist/either/optional/filled.d.ts

@@ -0,0 +1,17 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "../right";
+import { optional } from "./create";
+import { eitherOptionalKind } from "./base";
+export declare const eitherOptionalFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-optional-filled", unknown>>;
+type _EitherOptionalFilled<GenericValue extends unknown = unknown> = (EitherRight<"optional", GenericValue> & Kind<typeof eitherOptionalKind.definition> & Kind<typeof eitherOptionalFilledKind.definition>);
+export interface EitherOptionalFilled<GenericValue extends unknown = unknown> extends _EitherOptionalFilled<GenericValue> {
+}
+type Either = EitherRight | EitherLeft;
+export declare function optionalFilled<const GenericValue extends unknown>(value: GenericValue): EitherOptionalFilled<GenericValue>;
+export declare function isOptionalFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalFilled>;
+type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export {};

package/dist/either/optional/filled.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 { optional } from './create.mjs';
+import { eitherOptionalKind } from './base.mjs';
+
+const eitherOptionalFilledKind = createKind("either-optional-filled");
+function optionalFilled(value) {
+    return eitherOptionalKind.addTo(eitherOptionalFilledKind.addTo(right("optional", value)));
+}
+function isOptionalFilled(input) {
+    return isRight(input)
+        && eitherOptionalKind.has(input)
+        && eitherOptionalFilledKind.has(input);
+}
+function whenIsOptionalFilled(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsOptionalFilled(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return input;
+    }
+    else if (!isOptionalFilled(input) && isRight(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : optional(input);
+    if (isOptionalFilled(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, whenIsOptionalFilled };

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

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

package/dist/either/right/asyncPipe.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var unwrap = require('../../common/unwrap.cjs');
+var is = require('../left/is.cjs');
+var create = require('../future/create.cjs');
+var success = require('./success.cjs');
+var is$1 = require('./is.cjs');
+
+function rightAsyncPipe(input, ...pipes) {
+    return create.future((async () => {
+        const awaitedInput = await input;
+        if (is.isLeft(awaitedInput)) {
+            return awaitedInput;
+        }
+        let acc = is$1.isRight(awaitedInput)
+            ? awaitedInput
+            : success.success(awaitedInput);
+        for (const pipe of pipes) {
+            acc = await pipe(unwrap.unwrap(acc));
+            if (is.isLeft(acc)) {
+                return acc;
+            }
+        }
+        return acc;
+    })());
+}
+
+exports.rightAsyncPipe = rightAsyncPipe;

package/dist/either/right/asyncPipe.d.ts

@@ -0,0 +1,22 @@
+import { type EitherRight } from "./create";
+import { type EitherLeft } from "../left";
+import { type MaybeFutureEither } from "../future/maybeFutureEither";
+import { type Future } from "../future";
+import { type EitherSuccess } from "./success";
+import { type Unwrap, type AnyValue } from "../../common";
+type Either = EitherRight | EitherLeft;
+type EitherOrFutureEither = Either | Future<any>;
+export type EitherRightAsyncPipeFunction<GenericInput extends Either = Either, GenericOutput extends EitherOrFutureEither = EitherOrFutureEither> = (input: Unwrap<Extract<GenericInput, EitherRight>>) => GenericOutput;
+export type EitherRightAsyncPipeResult<GenericInput extends EitherOrFutureEither, GenericOutputPipes extends EitherOrFutureEither, GenericLastPipe extends EitherOrFutureEither> = Extract<GenericInput | GenericOutputPipes, EitherLeft> | Extract<GenericLastPipe, EitherRight>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : EitherSuccess<GenericValue>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1, GenericOutputPipe1>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2, GenericOutputPipe2>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3, GenericOutputPipe3>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4, GenericOutputPipe4>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5, GenericOutputPipe5>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6, GenericOutputPipe6>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7, GenericOutputPipe7>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither, GenericOutputPipe8 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>, pipe8: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe7>, GenericOutputPipe8>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8, GenericOutputPipe8>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither, GenericOutputPipe8 extends EitherOrFutureEither, GenericOutputPipe9 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>, pipe8: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe7>, GenericOutputPipe8>, pipe9: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe8>, GenericOutputPipe9>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8 | GenericOutputPipe9, GenericOutputPipe9>, any>>;
+export declare function rightAsyncPipe<GenericInput extends MaybeFutureEither<AnyValue>, GenericOutputPipe1 extends EitherOrFutureEither, GenericOutputPipe2 extends EitherOrFutureEither, GenericOutputPipe3 extends EitherOrFutureEither, GenericOutputPipe4 extends EitherOrFutureEither, GenericOutputPipe5 extends EitherOrFutureEither, GenericOutputPipe6 extends EitherOrFutureEither, GenericOutputPipe7 extends EitherOrFutureEither, GenericOutputPipe8 extends EitherOrFutureEither, GenericOutputPipe9 extends EitherOrFutureEither, GenericOutputPipe10 extends EitherOrFutureEither>(input: GenericInput, pipe1: EitherRightAsyncPipeFunction<ToEither<Awaited<GenericInput>>, GenericOutputPipe1>, pipe2: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe1>, GenericOutputPipe2>, pipe3: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe2>, GenericOutputPipe3>, pipe4: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe3>, GenericOutputPipe4>, pipe5: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe4>, GenericOutputPipe5>, pipe6: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe5>, GenericOutputPipe6>, pipe7: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe6>, GenericOutputPipe7>, pipe8: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe7>, GenericOutputPipe8>, pipe9: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe8>, GenericOutputPipe9>, pipe10: EitherRightAsyncPipeFunction<Awaited<GenericOutputPipe9>, GenericOutputPipe10>): Future<Extract<EitherRightAsyncPipeResult<ToEither<Awaited<GenericInput>>, GenericOutputPipe1 | GenericOutputPipe2 | GenericOutputPipe3 | GenericOutputPipe4 | GenericOutputPipe5 | GenericOutputPipe6 | GenericOutputPipe7 | GenericOutputPipe8 | GenericOutputPipe9 | GenericOutputPipe10, GenericOutputPipe10>, any>>;
+export {};

package/dist/either/right/asyncPipe.mjs

@@ -0,0 +1,26 @@
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { future } from '../future/create.mjs';
+import { success } from './success.mjs';
+import { isRight } from './is.mjs';
+
+function rightAsyncPipe(input, ...pipes) {
+    return future((async () => {
+        const awaitedInput = await input;
+        if (isLeft(awaitedInput)) {
+            return awaitedInput;
+        }
+        let acc = isRight(awaitedInput)
+            ? awaitedInput
+            : success(awaitedInput);
+        for (const pipe of pipes) {
+            acc = await pipe(unwrap(acc));
+            if (isLeft(acc)) {
+                return acc;
+            }
+        }
+        return acc;
+    })());
+}
+
+export { rightAsyncPipe };

package/dist/either/right/create.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var base = require('../base.cjs');
+
+const eitherRightKind = kind.createKind("either-right");
+function right(information, value = undefined) {
+    return eitherRightKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+}
+
+exports.eitherRightKind = eitherRightKind;
+exports.right = right;

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

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common/kind";
+import { type WrappedValue } from "../../common/wrapValue";
+import { eitherInformationKind } from "../base";
+export declare const eitherRightKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-right", unknown>>;
+type _EitherRight<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherRightKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
+export interface EitherRight<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _EitherRight<GenericInformation, GenericValue> {
+}
+export declare function right<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): EitherRight<GenericInformation, GenericValue>;
+export {};

package/dist/either/right/create.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../../common/kind.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+import { eitherInformationKind } from '../base.mjs';
+
+const eitherRightKind = createKind("either-right");
+function right(information, value = undefined) {
+    return eitherRightKind.addTo(eitherInformationKind.addTo(wrapValue(value), information));
+}
+
+export { eitherRightKind, right };

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

@@ -0,0 +1,7 @@
+export * from "./asyncPipe";
+export * from "./create";
+export * from "./is";
+export * from "./ok";
+export * from "./pipe";
+export * from "./success";
+export * from "./when";