@duplojs/utils 0.3.0 → 1.0.0

package/dist/either/right/pipe.mjs

@@ -0,0 +1,20 @@
+import { unwrap } from '../../common/unwrap.mjs';
+import { isLeft } from '../left/is.mjs';
+import { success } from './success.mjs';
+import { isRight } from './is.mjs';
+
+/* eslint-disable @typescript-eslint/max-params */
+function rightPipe(input, ...pipes) {
+    let acc = isRight(input) || isLeft(input)
+        ? input
+        : success(input);
+    for (const pipe of pipes) {
+        acc = pipe(unwrap(acc));
+        if (isLeft(acc)) {
+            return acc;
+        }
+    }
+    return acc;
+}
+
+export { rightPipe };

package/dist/either/right/success.cjs

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

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

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

package/dist/either/right/success.mjs

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

package/dist/either/right/when.cjs

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

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

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

package/dist/either/right/when.mjs

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

package/dist/either/whenHasInformation.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var unwrap = require('../common/unwrap.cjs');
+var base = require('./base.cjs');
+var is = require('./left/is.cjs');
+var is$1 = require('./right/is.cjs');
+
+function whenHasInformation(...args) {
+    if (args.length === 2) {
+        const [information, theFunction] = args;
+        return (input) => whenHasInformation(input, information, theFunction);
+    }
+    const [input, information, theFunction] = args;
+    const formattedInformation = information instanceof Array
+        ? information
+        : [information];
+    if ((is.isLeft(input)
+        || is$1.isRight(input)) && formattedInformation.includes(base.eitherInformationKind.getValue(input))) {
+        return theFunction(unwrap.unwrap(input));
+    }
+    return input;
+}
+
+exports.whenHasInformation = whenHasInformation;

package/dist/either/whenHasInformation.d.ts

@@ -0,0 +1,8 @@
+import { type Kind, type WrappedValue, type AnyValue, type Unwrap } from "../common";
+import { type EitherRight } from "./right";
+import { type EitherLeft } from "./left";
+import { eitherInformationKind } from "./base";
+type Either = EitherRight | EitherLeft;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(input: GenericInput, information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export {};

package/dist/either/whenHasInformation.mjs

@@ -0,0 +1,22 @@
+import { unwrap } from '../common/unwrap.mjs';
+import { eitherInformationKind } from './base.mjs';
+import { isLeft } from './left/is.mjs';
+import { isRight } from './right/is.mjs';
+
+function whenHasInformation(...args) {
+    if (args.length === 2) {
+        const [information, theFunction] = args;
+        return (input) => whenHasInformation(input, information, theFunction);
+    }
+    const [input, information, theFunction] = args;
+    const formattedInformation = information instanceof Array
+        ? information
+        : [information];
+    if ((isLeft(input)
+        || isRight(input)) && formattedInformation.includes(eitherInformationKind.getValue(input))) {
+        return theFunction(unwrap(input));
+    }
+    return input;
+}
+
+export { whenHasInformation };

package/dist/generator/asyncFilter.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+function asyncFilter(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (iterator) => asyncFilter(iterator, predicate);
+    }
+    const [iterator, predicate] = args;
+    let index = 0;
+    return (async function* () {
+        for await (const element of iterator) {
+            if (predicate(element, { index })) {
+                yield element;
+            }
+            index++;
+        }
+    })();
+}
+
+exports.asyncFilter = asyncFilter;

package/dist/generator/asyncFilter.d.ts

@@ -0,0 +1,8 @@
+interface AsyncGeneratorFilterParams {
+    index: number;
+}
+export declare function asyncFilter<GenericElement extends unknown, GenericOutput extends GenericElement>(predicate: (item: GenericElement, params: AsyncGeneratorFilterParams) => item is GenericOutput): (iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>) => AsyncGenerator<GenericOutput, unknown, unknown>;
+export declare function asyncFilter<GenericElement extends unknown, GenericOutput extends GenericElement>(iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>, predicate: (item: GenericElement, params: AsyncGeneratorFilterParams) => item is GenericOutput): AsyncGenerator<GenericOutput, unknown, unknown>;
+export declare function asyncFilter<GenericElement extends unknown>(predicate: (item: GenericElement, params: AsyncGeneratorFilterParams) => boolean): (iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>) => AsyncGenerator<GenericElement, unknown, unknown>;
+export declare function asyncFilter<GenericElement extends unknown>(iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>, predicate: (item: GenericElement, params: AsyncGeneratorFilterParams) => boolean): AsyncGenerator<GenericElement, unknown, unknown>;
+export {};

package/dist/generator/asyncFilter.mjs

@@ -0,0 +1,18 @@
+function asyncFilter(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (iterator) => asyncFilter(iterator, predicate);
+    }
+    const [iterator, predicate] = args;
+    let index = 0;
+    return (async function* () {
+        for await (const element of iterator) {
+            if (predicate(element, { index })) {
+                yield element;
+            }
+            index++;
+        }
+    })();
+}
+
+export { asyncFilter };

package/dist/generator/asyncLoop.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+async function* asyncLoop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = await loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            if (result["-exitData"] !== undefined) {
+                yield result["-exitData"];
+            }
+            break;
+        }
+        previousOutput = result["-nextData"];
+        if (previousOutput !== undefined) {
+            yield previousOutput;
+        }
+    }
+    return;
+}
+
+exports.asyncLoop = asyncLoop;

package/dist/generator/asyncLoop.d.ts

@@ -0,0 +1,10 @@
+import { type AnyValue } from "../common";
+import { type GeneratorLoopParams } from "./loop";
+interface LoopOutputExistResult<GenericOutput extends any> {
+    "-exitData": GenericOutput | undefined;
+}
+interface LoopOutputNextResult<GenericOutput extends any> {
+    "-nextData": GenericOutput | undefined;
+}
+export declare function asyncLoop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: GeneratorLoopParams<GenericRawNextOutput>) => Promise<LoopOutputNextResult<GenericRawNextOutput> | LoopOutputNextResult<undefined> | LoopOutputExistResult<GenericRawExitOutput> | LoopOutputExistResult<undefined>>): AsyncGenerator<Exclude<GenericRawExitOutput | GenericRawNextOutput, undefined>, unknown, unknown>;
+export {};

package/dist/generator/asyncLoop.mjs

@@ -0,0 +1,24 @@
+async function* asyncLoop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = await loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            if (result["-exitData"] !== undefined) {
+                yield result["-exitData"];
+            }
+            break;
+        }
+        previousOutput = result["-nextData"];
+        if (previousOutput !== undefined) {
+            yield previousOutput;
+        }
+    }
+    return;
+}
+
+export { asyncLoop };

package/dist/generator/asyncMap.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function asyncMap(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => asyncMap(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    let index = 0;
+    return (async function* () {
+        for await (const element of iterator) {
+            yield theFunction(element, { index });
+            index++;
+        }
+    })();
+}
+
+exports.asyncMap = asyncMap;

package/dist/generator/asyncMap.d.ts

@@ -0,0 +1,6 @@
+interface AsyncGeneratorMapParams {
+    index: number;
+}
+export declare function asyncMap<const GenericInput extends unknown, const GenericOutput extends unknown>(theFunction: (arg: GenericInput, params: AsyncGeneratorMapParams) => Promise<GenericOutput>): (iterator: AsyncIterable<GenericInput> | Iterable<GenericInput>) => AsyncGenerator<GenericOutput, unknown, unknown>;
+export declare function asyncMap<const GenericInput extends unknown, const GenericOutput extends unknown>(iterator: AsyncIterable<GenericInput> | Iterable<GenericInput>, theFunction: (arg: GenericInput, params: AsyncGeneratorMapParams) => Promise<GenericOutput>): AsyncGenerator<GenericOutput, unknown, unknown>;
+export {};

package/dist/generator/asyncMap.mjs

@@ -0,0 +1,16 @@
+function asyncMap(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => asyncMap(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    let index = 0;
+    return (async function* () {
+        for await (const element of iterator) {
+            yield theFunction(element, { index });
+            index++;
+        }
+    })();
+}
+
+export { asyncMap };

package/dist/generator/asyncReduce.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var override = require('../object/override.cjs');
+
+const generatorAsyncReduceFromKind = kind.createKind("generator-async-reduce-from");
+const getStartValueParams = {
+    from: (value) => generatorAsyncReduceFromKind.addTo(wrapValue.wrapValue(value), null),
+};
+function asyncReduce(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (iterator) => asyncReduce(iterator, getStartValue, theFunction);
+    }
+    const [iterator, getStartValue, theFunction] = args;
+    let lastValue = unwrap.unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    return (async () => {
+        let index = 0;
+        for await (const element of iterator) {
+            const result = theFunction({
+                element,
+                index,
+                lastValue,
+                nextWithObject: ((object1, object2) => ({
+                    "-next": override.override(object1, object2),
+                })),
+                exit: (output) => ({ "-exit": output }),
+                next: (output) => ({ "-next": output }),
+            });
+            if ("-exit" in result) {
+                return result["-exit"];
+            }
+            lastValue = result["-next"];
+            index++;
+        }
+        return lastValue;
+    })();
+}
+
+exports.asyncReduce = asyncReduce;

package/dist/generator/asyncReduce.d.ts

@@ -0,0 +1,30 @@
+import { type Kind } from "../common/kind";
+import { type WrappedValue } from "../common/wrapValue";
+import { type Unwrap } from "../common/unwrap";
+import { type ToLargeEnsemble } from "../common";
+interface AsyncGeneratorReduceNext<GenericOutput extends unknown> {
+    "-next": GenericOutput;
+}
+interface ArrayReduceExit<GenericOutput extends unknown> {
+    "-exit": GenericOutput;
+}
+type ExitOrNext<GenericOutput extends unknown = unknown> = ArrayReduceExit<GenericOutput> | AsyncGeneratorReduceNext<GenericOutput>;
+export interface AsyncGeneratorReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
+    element: GenericElement;
+    index: number;
+    lastValue: GenericOutput;
+    nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => AsyncGeneratorReduceNext<GenericOutput> : undefined;
+    next(output: GenericOutput): AsyncGeneratorReduceNext<GenericOutput>;
+    exit(output: GenericOutput): ArrayReduceExit<GenericOutput>;
+}
+declare const generatorAsyncReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"generator-async-reduce-from", unknown>>;
+export interface AsyncGeneratorReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof generatorAsyncReduceFromKind.definition>, WrappedValue<GenericValue> {
+}
+interface GetStartValueParams {
+    from<GenericValue extends unknown>(value: GenericValue): AsyncGeneratorReduceFromResult<GenericValue>;
+}
+export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(startValue: GenericReduceFrom, theFunction: (params: AsyncGeneratorReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): (iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>) => Promise<ToLargeEnsemble<GenericReduceFrom>>;
+export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends AsyncGeneratorReduceFromResult>(getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: AsyncGeneratorReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): (iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>) => Promise<Unwrap<GenericReduceFrom>>;
+export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>, startValue: GenericReduceFrom, theFunction: (params: AsyncGeneratorReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): Promise<ToLargeEnsemble<GenericReduceFrom>>;
+export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends AsyncGeneratorReduceFromResult>(iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>, getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: AsyncGeneratorReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): Promise<Unwrap<GenericReduceFrom>>;
+export {};

package/dist/generator/asyncReduce.mjs

@@ -0,0 +1,42 @@
+import { createKind } from '../common/kind.mjs';
+import { wrapValue } from '../common/wrapValue.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+import { override } from '../object/override.mjs';
+
+const generatorAsyncReduceFromKind = createKind("generator-async-reduce-from");
+const getStartValueParams = {
+    from: (value) => generatorAsyncReduceFromKind.addTo(wrapValue(value), null),
+};
+function asyncReduce(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (iterator) => asyncReduce(iterator, getStartValue, theFunction);
+    }
+    const [iterator, getStartValue, theFunction] = args;
+    let lastValue = unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    return (async () => {
+        let index = 0;
+        for await (const element of iterator) {
+            const result = theFunction({
+                element,
+                index,
+                lastValue,
+                nextWithObject: ((object1, object2) => ({
+                    "-next": override(object1, object2),
+                })),
+                exit: (output) => ({ "-exit": output }),
+                next: (output) => ({ "-next": output }),
+            });
+            if ("-exit" in result) {
+                return result["-exit"];
+            }
+            lastValue = result["-next"];
+            index++;
+        }
+        return lastValue;
+    })();
+}
+
+export { asyncReduce };

package/dist/generator/execute.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function execute(iterator) {
+    if (Symbol.iterator in iterator) {
+        for (const __ of iterator) {
+        }
+        return;
+    }
+    else {
+        return (async () => {
+            for await (const __ of iterator) {
+            }
+        })();
+    }
+}
+
+exports.execute = execute;

package/dist/generator/execute.d.ts

@@ -0,0 +1,2 @@
+import { type EscapeVoid } from "../common";
+export declare function execute<GenericIterator extends AsyncIterable<unknown> | Iterable<unknown>>(iterator: GenericIterator): GenericIterator extends AsyncIterable<unknown> ? Promise<void> : EscapeVoid;

package/dist/generator/execute.mjs

@@ -0,0 +1,15 @@
+function execute(iterator) {
+    if (Symbol.iterator in iterator) {
+        for (const __ of iterator) {
+        }
+        return;
+    }
+    else {
+        return (async () => {
+            for await (const __ of iterator) {
+            }
+        })();
+    }
+}
+
+export { execute };

package/dist/generator/filter.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+function filter(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (iterator) => filter(iterator, predicate);
+    }
+    const [iterator, predicate] = args;
+    let index = 0;
+    return (function* () {
+        for (const element of iterator) {
+            if (predicate(element, { index })) {
+                yield element;
+            }
+            index++;
+        }
+    })();
+}
+
+exports.filter = filter;

package/dist/generator/filter.d.ts

@@ -0,0 +1,8 @@
+interface GeneratorFilterParams {
+    index: number;
+}
+export declare function filter<GenericElement extends unknown, GenericOutput extends GenericElement>(predicate: (item: GenericElement, params: GeneratorFilterParams) => item is GenericOutput): (iterator: Iterable<GenericElement>) => Generator<GenericOutput, unknown, unknown>;
+export declare function filter<GenericElement extends unknown, GenericOutput extends GenericElement>(iterator: Iterable<GenericElement>, predicate: (item: GenericElement, params: GeneratorFilterParams) => item is GenericOutput): Generator<GenericOutput, unknown, unknown>;
+export declare function filter<GenericElement extends unknown>(predicate: (item: GenericElement, params: GeneratorFilterParams) => boolean): (iterator: Iterable<GenericElement>) => Generator<GenericElement, unknown, unknown>;
+export declare function filter<GenericElement extends unknown>(iterator: Iterable<GenericElement>, predicate: (item: GenericElement, params: GeneratorFilterParams) => boolean): Generator<GenericElement, unknown, unknown>;
+export {};

package/dist/generator/filter.mjs

@@ -0,0 +1,18 @@
+function filter(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (iterator) => filter(iterator, predicate);
+    }
+    const [iterator, predicate] = args;
+    let index = 0;
+    return (function* () {
+        for (const element of iterator) {
+            if (predicate(element, { index })) {
+                yield element;
+            }
+            index++;
+        }
+    })();
+}
+
+export { filter };

package/dist/generator/index.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var map = require('./map.cjs');
+var execute = require('./execute.cjs');
+var asyncMap = require('./asyncMap.cjs');
+var filter = require('./filter.cjs');
+var asyncFilter = require('./asyncFilter.cjs');
+var reduce = require('./reduce.cjs');
+var asyncReduce = require('./asyncReduce.cjs');
+var loop = require('./loop.cjs');
+var asyncLoop = require('./asyncLoop.cjs');
+
+
+
+exports.map = map.map;
+exports.execute = execute.execute;
+exports.asyncMap = asyncMap.asyncMap;
+exports.filter = filter.filter;
+exports.asyncFilter = asyncFilter.asyncFilter;
+exports.reduce = reduce.reduce;
+exports.asyncReduce = asyncReduce.asyncReduce;
+exports.loop = loop.loop;
+exports.asyncLoop = asyncLoop.asyncLoop;

package/dist/generator/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./map";
+export * from "./execute";
+export * from "./asyncMap";
+export * from "./filter";
+export * from "./asyncFilter";
+export * from "./reduce";
+export * from "./asyncReduce";
+export * from "./loop";
+export * from "./asyncLoop";

package/dist/generator/index.mjs

@@ -0,0 +1,9 @@
+export { map } from './map.mjs';
+export { execute } from './execute.mjs';
+export { asyncMap } from './asyncMap.mjs';
+export { filter } from './filter.mjs';
+export { asyncFilter } from './asyncFilter.mjs';
+export { reduce } from './reduce.mjs';
+export { asyncReduce } from './asyncReduce.mjs';
+export { loop } from './loop.mjs';
+export { asyncLoop } from './asyncLoop.mjs';

package/dist/generator/loop.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+function* loop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            if (result["-exitData"] !== undefined) {
+                yield result["-exitData"];
+            }
+            break;
+        }
+        previousOutput = result["-nextData"];
+        if (previousOutput !== undefined) {
+            yield previousOutput;
+        }
+    }
+    return;
+}
+
+exports.loop = loop;

package/dist/generator/loop.d.ts

@@ -0,0 +1,15 @@
+import { type AnyValue } from "../common";
+interface LoopOutputExistResult<GenericOutput extends any> {
+    "-exitData": GenericOutput | undefined;
+}
+interface LoopOutputNextResult<GenericOutput extends any> {
+    "-nextData": GenericOutput | undefined;
+}
+export interface GeneratorLoopParams<GenericRawNextOutput extends any> {
+    count: number;
+    previousOutput: GenericRawNextOutput | undefined;
+    next<GenericValue extends GenericRawNextOutput | undefined = undefined>(output?: GenericValue): LoopOutputNextResult<GenericValue>;
+    exit<GenericOutput extends AnyValue = undefined>(output?: GenericOutput): LoopOutputExistResult<GenericOutput>;
+}
+export declare function loop<GenericRawExitOutput extends AnyValue = undefined, GenericRawNextOutput extends AnyValue = undefined>(loop: (params: GeneratorLoopParams<GenericRawNextOutput>) => LoopOutputNextResult<GenericRawNextOutput> | LoopOutputNextResult<undefined> | LoopOutputExistResult<GenericRawExitOutput> | LoopOutputExistResult<undefined>): Generator<Exclude<GenericRawExitOutput | GenericRawNextOutput, undefined>, unknown, unknown>;
+export {};

package/dist/generator/loop.mjs

@@ -0,0 +1,24 @@
+function* loop(loop) {
+    let previousOutput = undefined;
+    for (let count = 0; true; count++) {
+        const result = loop({
+            previousOutput,
+            count,
+            next: (data) => ({ "-nextData": data }),
+            exit: (data) => ({ "-exitData": data }),
+        });
+        if ("-exitData" in result) {
+            if (result["-exitData"] !== undefined) {
+                yield result["-exitData"];
+            }
+            break;
+        }
+        previousOutput = result["-nextData"];
+        if (previousOutput !== undefined) {
+            yield previousOutput;
+        }
+    }
+    return;
+}
+
+export { loop };