@duplojs/utils 0.3.0 → 1.0.0

package/dist/either/index.mjs

@@ -0,0 +1,35 @@
+export { bool } from './bool/create.mjs';
+export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
+export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';
+export { eitherBoolKind } from './bool/base.mjs';
+export { Future, future } from './future/create.mjs';
+export { eitherFutureErrorKind, futureError } from './future/error.mjs';
+export { eitherFutureSuccessKind, futureSuccess } from './future/success.mjs';
+export { eitherFutureKind } from './future/base.mjs';
+export { eitherLeftKind, left } from './left/create.mjs';
+export { eitherErrorKind, error } from './left/error.mjs';
+export { eitherFailKind, fail } from './left/fail.mjs';
+export { isLeft } from './left/is.mjs';
+export { whenIsLeft } from './left/when.mjs';
+export { nullable } from './nullable/create.mjs';
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty } from './nullable/empty.mjs';
+export { eitherNullableFilledKind, isNullableFilled, nullableFilled, whenIsNullableFilled } from './nullable/filled.mjs';
+export { eitherNullableKind } from './nullable/base.mjs';
+export { nullish } from './nullish/create.mjs';
+export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, whenIsNullishEmpty } from './nullish/empty.mjs';
+export { eitherNullishFilledKind, isNullishFilled, nullishFilled, whenIsNullishFilled } from './nullish/filled.mjs';
+export { eitherNullishKind } from './nullish/base.mjs';
+export { optional } from './optional/create.mjs';
+export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, whenIsOptionalEmpty } from './optional/empty.mjs';
+export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, whenIsOptionalFilled } from './optional/filled.mjs';
+export { eitherOptionalKind } from './optional/base.mjs';
+export { rightAsyncPipe } from './right/asyncPipe.mjs';
+export { eitherRightKind, right } from './right/create.mjs';
+export { isRight } from './right/is.mjs';
+export { eitherOkKind, ok } from './right/ok.mjs';
+export { rightPipe } from './right/pipe.mjs';
+export { eitherSuccessKind, success } from './right/success.mjs';
+export { whenIsRight } from './right/when.mjs';
+export { hasInformation } from './hasInformation.mjs';
+export { whenHasInformation } from './whenHasInformation.mjs';
+export { eitherInformationKind } from './base.mjs';

package/dist/either/left/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 eitherLeftKind = kind.createKind("either-left");
+function left(information, value = undefined) {
+    return eitherLeftKind.addTo(base.eitherInformationKind.addTo(wrapValue.wrapValue(value), information));
+}
+
+exports.eitherLeftKind = eitherLeftKind;
+exports.left = left;

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

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

package/dist/either/left/create.mjs

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

package/dist/either/left/error.cjs

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

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

@@ -0,0 +1,5 @@
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "./create";
+export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-error", unknown>>;
+export type EitherError<GenericValue extends unknown = unknown> = (EitherLeft<"error", GenericValue> & Kind<typeof eitherErrorKind.definition>);
+export declare function error<const GenericValue extends unknown>(value: GenericValue): EitherError<GenericValue>;

package/dist/either/left/error.mjs

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

package/dist/either/left/fail.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+var create = require('./create.cjs');
+
+const eitherFailKind = kind.createKind("either-fail");
+function fail() {
+    return eitherFailKind.addTo(create.left("fail", undefined));
+}
+
+exports.eitherFailKind = eitherFailKind;
+exports.fail = fail;

package/dist/either/left/fail.d.ts

@@ -0,0 +1,5 @@
+import { type Kind } from "../../common/kind";
+import { type EitherLeft } from "./create";
+export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"either-fail", unknown>>;
+export type EitherFail = (EitherLeft<"fail", never> & Kind<typeof eitherFailKind.definition>);
+export declare function fail(): EitherFail;

package/dist/either/left/fail.mjs

@@ -0,0 +1,9 @@
+import { createKind } from '../../common/kind.mjs';
+import { left } from './create.mjs';
+
+const eitherFailKind = createKind("either-fail");
+function fail() {
+    return eitherFailKind.addTo(left("fail", undefined));
+}
+
+export { eitherFailKind, fail };

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

@@ -0,0 +1,5 @@
+export * from "./create";
+export * from "./error";
+export * from "./fail";
+export * from "./is";
+export * from "./when";

package/dist/either/left/is.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var create = require('./create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+var base = require('../base.cjs');
+
+function isLeft(input) {
+    return create.eitherLeftKind.has(input)
+        && base.eitherInformationKind.has(input)
+        && wrapValue.isWrappedValue(input);
+}
+
+exports.isLeft = isLeft;

package/dist/either/left/is.d.ts

@@ -0,0 +1,2 @@
+import { type EitherLeft } from "./create";
+export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherLeft>;

package/dist/either/left/is.mjs

@@ -0,0 +1,11 @@
+import { eitherLeftKind } from './create.mjs';
+import { isWrappedValue } from '../../common/wrapValue.mjs';
+import { eitherInformationKind } from '../base.mjs';
+
+function isLeft(input) {
+    return eitherLeftKind.has(input)
+        && eitherInformationKind.has(input)
+        && isWrappedValue(input);
+}
+
+export { isLeft };

package/dist/either/left/when.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var unwrap = require('../../common/unwrap.cjs');
+var is = require('./is.cjs');
+
+function whenIsLeft(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsLeft(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is.isLeft(input)) {
+        return theFunction(unwrap.unwrap(input));
+    }
+    return input;
+}
+
+exports.whenIsLeft = whenIsLeft;

package/dist/either/left/when.d.ts

@@ -0,0 +1,4 @@
+import { type EscapeVoid, type AnyValue, type Unwrap } from "../../common";
+import { type EitherLeft } from "./create";
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<GenericInput, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;

package/dist/either/left/when.mjs

@@ -0,0 +1,16 @@
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from './is.mjs';
+
+function whenIsLeft(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsLeft(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isLeft(input)) {
+        return theFunction(unwrap(input));
+    }
+    return input;
+}
+
+export { whenIsLeft };

package/dist/either/nullable/base.cjs

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

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

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

package/dist/either/nullable/base.mjs

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

package/dist/either/nullable/create.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var empty = require('./empty.cjs');
+var filled = require('./filled.cjs');
+
+function nullable(value) {
+    return value === null
+        ? empty.nullableEmpty()
+        : filled.nullableFilled(value);
+}
+
+exports.nullable = nullable;

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

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

package/dist/either/nullable/create.mjs

@@ -0,0 +1,10 @@
+import { nullableEmpty } from './empty.mjs';
+import { nullableFilled } from './filled.mjs';
+
+function nullable(value) {
+    return value === null
+        ? nullableEmpty()
+        : nullableFilled(value);
+}
+
+export { nullable };

package/dist/either/nullable/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 eitherNullableEmptyKind = kind.createKind("either-nullable-empty");
+function nullableEmpty() {
+    return base.eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(create.left("nullable", null)));
+}
+function isNullableEmpty(input) {
+    return is.isLeft(input)
+        && base.eitherNullableKind.has(input)
+        && eitherNullableEmptyKind.has(input);
+}
+function whenIsNullableEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullableEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (is$1.isRight(input)) {
+        return input;
+    }
+    else if (!isNullableEmpty(input) && is.isLeft(input)) {
+        return input;
+    }
+    const either = is$1.isRight(input) || is.isLeft(input)
+        ? input
+        : create$1.nullable(input);
+    if (isNullableEmpty(either)) {
+        return theFunction(unwrap.unwrap(either));
+    }
+    return either;
+}
+
+exports.eitherNullableEmptyKind = eitherNullableEmptyKind;
+exports.isNullableEmpty = isNullableEmpty;
+exports.nullableEmpty = nullableEmpty;
+exports.whenIsNullableEmpty = whenIsNullableEmpty;

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

@@ -0,0 +1,15 @@
+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 { nullable } from "./create";
+import { eitherNullableKind } from "./base";
+export declare const eitherNullableEmptyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullable-empty", unknown>>;
+export type EitherNullableEmpty = (EitherLeft<"nullable", null> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableEmptyKind.definition>);
+type Either = EitherRight | EitherLeft;
+export declare function nullableEmpty(): EitherNullableEmpty;
+export declare function isNullableEmpty<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableEmpty>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
+export declare function whenIsNullableEmpty<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableEmpty>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableEmpty>;
+export {};

package/dist/either/nullable/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 { nullable } from './create.mjs';
+import { eitherNullableKind } from './base.mjs';
+
+const eitherNullableEmptyKind = createKind("either-nullable-empty");
+function nullableEmpty() {
+    return eitherNullableKind.addTo(eitherNullableEmptyKind.addTo(left("nullable", null)));
+}
+function isNullableEmpty(input) {
+    return isLeft(input)
+        && eitherNullableKind.has(input)
+        && eitherNullableEmptyKind.has(input);
+}
+function whenIsNullableEmpty(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => whenIsNullableEmpty(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    if (isRight(input)) {
+        return input;
+    }
+    else if (!isNullableEmpty(input) && isLeft(input)) {
+        return input;
+    }
+    const either = isRight(input) || isLeft(input)
+        ? input
+        : nullable(input);
+    if (isNullableEmpty(either)) {
+        return theFunction(unwrap(either));
+    }
+    return either;
+}
+
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty };

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

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

@@ -0,0 +1,15 @@
+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 { nullable } from "./create";
+import { eitherNullableKind } from "./base";
+export declare const eitherNullableFilledKind: import("../../common").KindHandler<import("../../common").KindDefinition<"either-nullable-filled", unknown>>;
+export type EitherNullableFilled<GenericValue extends unknown = unknown> = (EitherRight<"nullable", GenericValue> & Kind<typeof eitherNullableKind.definition> & Kind<typeof eitherNullableFilledKind.definition>);
+type Either = EitherRight | EitherLeft;
+export declare function nullableFilled<const GenericValue extends unknown>(value: GenericValue): EitherNullableFilled<GenericValue>;
+export declare function isNullableFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherNullableFilled>;
+type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof nullable<GenericValue>>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export declare function whenIsNullableFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<GenericInput>, EitherNullableFilled>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherNullableFilled>;
+export {};

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

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

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

package/dist/either/nullish/base.cjs

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

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

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

package/dist/either/nullish/base.mjs

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

package/dist/either/nullish/create.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var empty = require('./empty.cjs');
+var filled = require('./filled.cjs');
+
+function nullish(value) {
+    return value === null || value === undefined
+        ? empty.nullishEmpty(value)
+        : filled.nullishFilled(value);
+}
+
+exports.nullish = nullish;

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,16 @@
+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>>;
+export type EitherNullishEmpty<GenericValue extends NullishValue = NullishValue> = (EitherLeft<"nullish", GenericValue> & Kind<typeof eitherNullishKind.definition> & Kind<typeof eitherNullishEmptyKind.definition>);
+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 };