@duplojs/lang 0.0.0

package/dist/invocation/flow/base.mjs

@@ -0,0 +1,17 @@
+import { callThen } from "../../common/callThen.mjs";
+import { forward } from "../../common/forward.mjs";
+import { flowControllerExitKind, flowControllerKind } from "./controller/base.mjs";
+//#region scripts/invocation/flow/base.ts
+function flow(...args) {
+	const accumulateFunction = args.reduce((accumulator, currentValue) => {
+		if (flowControllerKind.has(currentValue)) return (arg) => currentValue.exec(() => accumulator(arg));
+		else {
+			const preparedResultTreatment = (result) => flowControllerExitKind.has(result) ? result : currentValue(result);
+			return (arg) => callThen(accumulator(arg), preparedResultTreatment);
+		}
+	}, forward);
+	const preparedResultTreatment = (result) => flowControllerExitKind.has(result) ? flowControllerExitKind.getValue(result) : result;
+	return (arg) => callThen(accumulateFunction(arg), preparedResultTreatment);
+}
+//#endregion
+export { flow };

package/dist/invocation/flow/controller/base.cjs

@@ -0,0 +1,18 @@
+const require_kind = require("../../kind.cjs");
+//#region scripts/invocation/flow/controller/base.ts
+const flowControllerExitKind = require_kind.createKind("flow-controller-exit");
+const flowControllerKind = require_kind.createKind("flow-controller");
+function createFlowController(kindHandler, createConstructor) {
+	return createConstructor({
+		init: (exec) => ({
+			exec,
+			[flowControllerKind.runTimeKey]: null,
+			[kindHandler.runTimeKey]: null
+		}),
+		exitFlow: (value) => ({ [flowControllerExitKind.runTimeKey]: value })
+	});
+}
+//#endregion
+exports.createFlowController = createFlowController;
+exports.flowControllerExitKind = flowControllerExitKind;
+exports.flowControllerKind = flowControllerKind;

package/dist/invocation/flow/controller/base.d.ts

@@ -0,0 +1,23 @@
+import { Evidence } from '../../evidence';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import type * as DEither from '../../../either';
+export declare const flowControllerExitKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-exit", unknown>>;
+export interface FlowControllerExit<GenericResult extends unknown = unknown> extends DKind.Kind<typeof flowControllerExitKind, GenericResult> {
+}
+export declare const flowControllerKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller", unknown>>;
+declare const FlowControllerResultSymbol: unique symbol;
+export type FlowControllerPreviousFunctionResult = DCommon.MaybePromise<(DCommon.AnyValue | DEither.Right | DEither.Left | FlowControllerExit) & Evidence<"PreviousFunctionResult">>;
+export interface FlowControllerResult<GenericResult extends unknown> {
+    readonly [FlowControllerResultSymbol]: GenericResult;
+}
+export interface FlowController<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof flowControllerKind> {
+    (this: never, input: GenericInput): FlowControllerResult<GenericOutput>;
+    exec(previousFunction: () => FlowControllerPreviousFunctionResult): (FlowControllerPreviousFunctionResult | GenericOutput | DCommon.MergePromise<FlowControllerPreviousFunctionResult | GenericOutput>);
+}
+export interface CreateFlowControllerConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
+    init<GenericFlowController extends (FlowController<any, any> & DKind.Kind<GenericKindHandler>)>(exec: GenericFlowController["exec"]): GenericFlowController;
+    exitFlow<GenericValue extends unknown>(value: GenericValue): FlowControllerExit<GenericValue>;
+}
+export declare function createFlowController<GenericKindHandler extends DKind.Handler, GenericConstructor extends ((...args: any[]) => (FlowController<any, any> & DKind.Kind<GenericKindHandler>))>(kindHandler: GenericKindHandler, createConstructor: (params: CreateFlowControllerConstructorParams<GenericKindHandler>) => GenericConstructor): GenericConstructor;
+export {};

package/dist/invocation/flow/controller/base.mjs

@@ -0,0 +1,16 @@
+import { createKind } from "../../kind.mjs";
+//#region scripts/invocation/flow/controller/base.ts
+const flowControllerExitKind = createKind("flow-controller-exit");
+const flowControllerKind = createKind("flow-controller");
+function createFlowController(kindHandler, createConstructor) {
+	return createConstructor({
+		init: (exec) => ({
+			exec,
+			[flowControllerKind.runTimeKey]: null,
+			[kindHandler.runTimeKey]: null
+		}),
+		exitFlow: (value) => ({ [flowControllerExitKind.runTimeKey]: value })
+	});
+}
+//#endregion
+export { createFlowController, flowControllerExitKind, flowControllerKind };

package/dist/invocation/flow/controller/defaults/debounce.cjs

@@ -0,0 +1,25 @@
+const require_externalPromise = require("../../../../common/externalPromise.cjs");
+const require_create = require("../../../../either/left/create.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/debounce.ts
+const flowControllerDebounceKind = require_kind.createKind("flow-controller-debounce");
+const debounce = require_base.createFlowController(flowControllerDebounceKind, ({ init, exitFlow }) => (debounce) => {
+	const formattedDebounceTime = require_stringToMillisecond.stringToMillisecond(debounce);
+	let lastTimeout = void 0;
+	let lastEvent = void 0;
+	return init(async (previousFunction) => {
+		const result = await previousFunction();
+		if (require_base.flowControllerExitKind.has(result)) return result;
+		clearTimeout(lastTimeout);
+		lastEvent?.resolve(false);
+		lastEvent = require_externalPromise.createExternalPromise();
+		lastTimeout = setTimeout(() => lastEvent?.resolve(true), formattedDebounceTime);
+		if (!await lastEvent.promise) return exitFlow(require_create.left("debounce-reject"));
+		return result;
+	});
+});
+//#endregion
+exports.debounce = debounce;
+exports.flowControllerDebounceKind = flowControllerDebounceKind;

package/dist/invocation/flow/controller/defaults/debounce.d.ts

@@ -0,0 +1,8 @@
+import { FlowControllerExit, FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import type * as DKind from '../../../../kind';
+import * as DEither from '../../../../either';
+export declare const flowControllerDebounceKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-debounce", unknown>>;
+export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
+}
+export declare const debounce: <GenericInput extends unknown = unknown>(debounce: DCommon.TimeInString) => FlowControllerDebounce<GenericInput>;

package/dist/invocation/flow/controller/defaults/debounce.mjs

@@ -0,0 +1,24 @@
+import { createExternalPromise } from "../../../../common/externalPromise.mjs";
+import { left } from "../../../../either/left/create.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
+import { createKind } from "../../../kind.mjs";
+import { createFlowController, flowControllerExitKind } from "../base.mjs";
+//#region scripts/invocation/flow/controller/defaults/debounce.ts
+const flowControllerDebounceKind = createKind("flow-controller-debounce");
+const debounce = createFlowController(flowControllerDebounceKind, ({ init, exitFlow }) => (debounce) => {
+	const formattedDebounceTime = stringToMillisecond(debounce);
+	let lastTimeout = void 0;
+	let lastEvent = void 0;
+	return init(async (previousFunction) => {
+		const result = await previousFunction();
+		if (flowControllerExitKind.has(result)) return result;
+		clearTimeout(lastTimeout);
+		lastEvent?.resolve(false);
+		lastEvent = createExternalPromise();
+		lastTimeout = setTimeout(() => lastEvent?.resolve(true), formattedDebounceTime);
+		if (!await lastEvent.promise) return exitFlow(left("debounce-reject"));
+		return result;
+	});
+});
+//#endregion
+export { debounce, flowControllerDebounceKind };

package/dist/invocation/flow/controller/defaults/filter.cjs

@@ -0,0 +1,16 @@
+const require_callThen = require("../../../../common/callThen.cjs");
+const require_is = require("../../../../either/left/is.cjs");
+const require_unwrap = require("../../../../either/right/unwrap.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/filter.ts
+const flowControllerFilterKind = require_kind.createKind("flow-controller-filter");
+const filter = require_base.createFlowController(flowControllerFilterKind, ({ init, exitFlow }) => (filterFunction) => init((previousFunction) => require_callThen.callThen(previousFunction(), (result) => {
+	if (require_base.flowControllerExitKind.has(result)) return result;
+	const filterResult = require_unwrap.unwrapRight(filterFunction(result));
+	if (require_is.isLeft(filterResult)) return exitFlow(filterResult);
+	return filterResult;
+})));
+//#endregion
+exports.filter = filter;
+exports.flowControllerFilterKind = flowControllerFilterKind;

package/dist/invocation/flow/controller/defaults/filter.d.ts

@@ -0,0 +1,8 @@
+import { FlowControllerExit, FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import type * as DKind from '../../../../kind';
+import * as DEither from '../../../../either';
+export declare const flowControllerFilterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-filter", unknown>>;
+export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, GenericOutput extends DEither.Left ? FlowControllerExit<GenericOutput> : GenericOutput extends DEither.Right ? DEither.GetValue<GenericOutput> : GenericOutput> & DKind.Kind<typeof flowControllerFilterKind>> {
+}
+export declare const filter: <GenericInput extends unknown, GenericOutput extends unknown>(filterFunction: (input: GenericInput) => GenericOutput) => FlowControllerFilter<GenericInput, GenericOutput>;

package/dist/invocation/flow/controller/defaults/filter.mjs

@@ -0,0 +1,15 @@
+import { callThen } from "../../../../common/callThen.mjs";
+import { isLeft } from "../../../../either/left/is.mjs";
+import { unwrapRight } from "../../../../either/right/unwrap.mjs";
+import { createKind } from "../../../kind.mjs";
+import { createFlowController, flowControllerExitKind } from "../base.mjs";
+//#region scripts/invocation/flow/controller/defaults/filter.ts
+const flowControllerFilterKind = createKind("flow-controller-filter");
+const filter = createFlowController(flowControllerFilterKind, ({ init, exitFlow }) => (filterFunction) => init((previousFunction) => callThen(previousFunction(), (result) => {
+	if (flowControllerExitKind.has(result)) return result;
+	const filterResult = unwrapRight(filterFunction(result));
+	if (isLeft(filterResult)) return exitFlow(filterResult);
+	return filterResult;
+})));
+//#endregion
+export { filter, flowControllerFilterKind };

package/dist/invocation/flow/controller/defaults/index.d.ts

@@ -0,0 +1,5 @@
+export * from './debounce';
+export * from './filter';
+export * from './retry';
+export * from './throttling';
+export * from './timeout';

package/dist/invocation/flow/controller/defaults/retry.cjs

@@ -0,0 +1,24 @@
+const require_timeout = require("../../../../common/timeout.cjs");
+const require_is = require("../../../../either/left/is.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/retry.ts
+const flowControllerRetryKind = require_kind.createKind("flow-controller-retry");
+const retry = require_base.createFlowController(flowControllerRetryKind, ({ init }) => ({ timeout: timeout$1, times }) => {
+	const formattedTimeout = timeout$1 && require_stringToMillisecond.stringToMillisecond(timeout$1);
+	const maxTimes = times ?? Infinity;
+	return init(async (previousFunction) => {
+		let result = void 0;
+		let count = 0;
+		do {
+			if (formattedTimeout && count !== 0) await require_timeout.timeout(formattedTimeout);
+			result = await previousFunction();
+			count++;
+		} while (require_is.isLeft(result) && count < maxTimes);
+		return result;
+	});
+});
+//#endregion
+exports.flowControllerRetryKind = flowControllerRetryKind;
+exports.retry = retry;

package/dist/invocation/flow/controller/defaults/retry.d.ts

@@ -0,0 +1,11 @@
+import { FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import type * as DKind from '../../../../kind';
+export declare const flowControllerRetryKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-retry", unknown>>;
+export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
+}
+export interface RetryParams {
+    times?: number;
+    timeout?: DCommon.TimeInString;
+}
+export declare const retry: <GenericInput extends unknown = unknown>({ timeout, times, }: RetryParams) => FlowControllerRetry<GenericInput>;

package/dist/invocation/flow/controller/defaults/retry.mjs

@@ -0,0 +1,23 @@
+import { timeout } from "../../../../common/timeout.mjs";
+import { isLeft } from "../../../../either/left/is.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
+import { createKind } from "../../../kind.mjs";
+import { createFlowController } from "../base.mjs";
+//#region scripts/invocation/flow/controller/defaults/retry.ts
+const flowControllerRetryKind = createKind("flow-controller-retry");
+const retry = createFlowController(flowControllerRetryKind, ({ init }) => ({ timeout: timeout$1, times }) => {
+	const formattedTimeout = timeout$1 && stringToMillisecond(timeout$1);
+	const maxTimes = times ?? Infinity;
+	return init(async (previousFunction) => {
+		let result = void 0;
+		let count = 0;
+		do {
+			if (formattedTimeout && count !== 0) await timeout(formattedTimeout);
+			result = await previousFunction();
+			count++;
+		} while (isLeft(result) && count < maxTimes);
+		return result;
+	});
+});
+//#endregion
+export { flowControllerRetryKind, retry };

package/dist/invocation/flow/controller/defaults/throttling.cjs

@@ -0,0 +1,27 @@
+const require_externalPromise = require("../../../../common/externalPromise.cjs");
+const require_create = require("../../../../either/left/create.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/throttling.ts
+const flowControllerThrottlingKind = require_kind.createKind("flow-controller-throttling");
+const throttling = require_base.createFlowController(flowControllerThrottlingKind, ({ init, exitFlow }) => (throttling) => {
+	const formattedThrottlingTime = require_stringToMillisecond.stringToMillisecond(throttling);
+	let lastTime = 0;
+	let lastEvent = void 0;
+	return init(async (previousFunction) => {
+		const result = await previousFunction();
+		if (require_base.flowControllerExitKind.has(result)) return result;
+		if (Date.now() - lastTime < formattedThrottlingTime) {
+			lastEvent?.resolve(false);
+			lastEvent = require_externalPromise.createExternalPromise();
+			if (!await lastEvent.promise) return exitFlow(require_create.left("throttling-reject"));
+		}
+		setTimeout(() => lastEvent?.resolve(true), formattedThrottlingTime);
+		lastTime = Date.now();
+		return result;
+	});
+});
+//#endregion
+exports.flowControllerThrottlingKind = flowControllerThrottlingKind;
+exports.throttling = throttling;

package/dist/invocation/flow/controller/defaults/throttling.d.ts

@@ -0,0 +1,8 @@
+import { FlowControllerExit, FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import type * as DKind from '../../../../kind';
+import * as DEither from '../../../../either';
+export declare const flowControllerThrottlingKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-throttling", unknown>>;
+export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
+}
+export declare const throttling: <GenericInput extends unknown = unknown>(throttling: DCommon.TimeInString) => FlowControllerThrottling<GenericInput>;

package/dist/invocation/flow/controller/defaults/throttling.mjs

@@ -0,0 +1,26 @@
+import { createExternalPromise } from "../../../../common/externalPromise.mjs";
+import { left } from "../../../../either/left/create.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
+import { createKind } from "../../../kind.mjs";
+import { createFlowController, flowControllerExitKind } from "../base.mjs";
+//#region scripts/invocation/flow/controller/defaults/throttling.ts
+const flowControllerThrottlingKind = createKind("flow-controller-throttling");
+const throttling = createFlowController(flowControllerThrottlingKind, ({ init, exitFlow }) => (throttling) => {
+	const formattedThrottlingTime = stringToMillisecond(throttling);
+	let lastTime = 0;
+	let lastEvent = void 0;
+	return init(async (previousFunction) => {
+		const result = await previousFunction();
+		if (flowControllerExitKind.has(result)) return result;
+		if (Date.now() - lastTime < formattedThrottlingTime) {
+			lastEvent?.resolve(false);
+			lastEvent = createExternalPromise();
+			if (!await lastEvent.promise) return exitFlow(left("throttling-reject"));
+		}
+		setTimeout(() => lastEvent?.resolve(true), formattedThrottlingTime);
+		lastTime = Date.now();
+		return result;
+	});
+});
+//#endregion
+export { flowControllerThrottlingKind, throttling };

package/dist/invocation/flow/controller/defaults/timeout.cjs

@@ -0,0 +1,18 @@
+const require_timeout = require("../../../../common/timeout.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/timeout.ts
+const flowControllerTimeoutKind = require_kind.createKind("flow-controller-timeout");
+const timeout = require_base.createFlowController(flowControllerTimeoutKind, ({ init }) => (timeout) => {
+	const formattedTimeout = require_stringToMillisecond.stringToMillisecond(timeout);
+	return init(async (previousFunction) => {
+		const result = await previousFunction();
+		if (require_base.flowControllerExitKind.has(result)) return result;
+		await require_timeout.timeout(formattedTimeout);
+		return result;
+	});
+});
+//#endregion
+exports.flowControllerTimeoutKind = flowControllerTimeoutKind;
+exports.timeout = timeout;

package/dist/invocation/flow/controller/defaults/timeout.d.ts

@@ -0,0 +1,7 @@
+import { FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import type * as DKind from '../../../../kind';
+export declare const flowControllerTimeoutKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-timeout", unknown>>;
+export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
+}
+export declare const timeout: <GenericInput extends unknown = unknown>(timeout: DCommon.TimeInString) => FlowControllerTimeout<GenericInput>;

package/dist/invocation/flow/controller/defaults/timeout.mjs

@@ -0,0 +1,17 @@
+import { timeout as timeout$1 } from "../../../../common/timeout.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
+import { createKind } from "../../../kind.mjs";
+import { createFlowController, flowControllerExitKind } from "../base.mjs";
+//#region scripts/invocation/flow/controller/defaults/timeout.ts
+const flowControllerTimeoutKind = createKind("flow-controller-timeout");
+const timeout = createFlowController(flowControllerTimeoutKind, ({ init }) => (timeout) => {
+	const formattedTimeout = stringToMillisecond(timeout);
+	return init(async (previousFunction) => {
+		const result = await previousFunction();
+		if (flowControllerExitKind.has(result)) return result;
+		await timeout$1(formattedTimeout);
+		return result;
+	});
+});
+//#endregion
+export { flowControllerTimeoutKind, timeout };

package/dist/invocation/flow/controller/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './defaults';

package/dist/invocation/flow/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './controller';

package/dist/invocation/index.cjs

@@ -0,0 +1,66 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_evidence = require("./evidence.cjs");
+const require_kind = require("./kind.cjs");
+const require_base = require("./flow/controller/base.cjs");
+const require_debounce = require("./flow/controller/defaults/debounce.cjs");
+const require_filter = require("./flow/controller/defaults/filter.cjs");
+const require_retry = require("./flow/controller/defaults/retry.cjs");
+const require_throttling = require("./flow/controller/defaults/throttling.cjs");
+const require_timeout = require("./flow/controller/defaults/timeout.cjs");
+const require_base$1 = require("./flow/base.cjs");
+const require_port = require("./port.cjs");
+const require_useCase = require("./useCase.cjs");
+//#region scripts/invocation/index.ts
+var invocation_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	appendEvidence: () => require_evidence.appendEvidence,
+	createFlowController: () => require_base.createFlowController,
+	createKind: () => require_kind.createKind,
+	createPort: () => require_port.createPort,
+	createUseCase: () => require_useCase.createUseCase,
+	debounce: () => require_debounce.debounce,
+	evidenceResult: () => require_evidence.evidenceResult,
+	filter: () => require_filter.filter,
+	flow: () => require_base$1.flow,
+	flowControllerDebounceKind: () => require_debounce.flowControllerDebounceKind,
+	flowControllerExitKind: () => require_base.flowControllerExitKind,
+	flowControllerFilterKind: () => require_filter.flowControllerFilterKind,
+	flowControllerKind: () => require_base.flowControllerKind,
+	flowControllerRetryKind: () => require_retry.flowControllerRetryKind,
+	flowControllerThrottlingKind: () => require_throttling.flowControllerThrottlingKind,
+	flowControllerTimeoutKind: () => require_timeout.flowControllerTimeoutKind,
+	portHandlerKind: () => require_port.portHandlerKind,
+	retry: () => require_retry.retry,
+	throttling: () => require_throttling.throttling,
+	timeout: () => require_timeout.timeout,
+	useCaseHandlerKind: () => require_useCase.useCaseHandlerKind,
+	wireUseCases: () => require_useCase.wireUseCases
+});
+//#endregion
+exports.appendEvidence = require_evidence.appendEvidence;
+exports.createFlowController = require_base.createFlowController;
+exports.createKind = require_kind.createKind;
+exports.createPort = require_port.createPort;
+exports.createUseCase = require_useCase.createUseCase;
+exports.debounce = require_debounce.debounce;
+exports.evidenceResult = require_evidence.evidenceResult;
+exports.filter = require_filter.filter;
+exports.flow = require_base$1.flow;
+exports.flowControllerDebounceKind = require_debounce.flowControllerDebounceKind;
+exports.flowControllerExitKind = require_base.flowControllerExitKind;
+exports.flowControllerFilterKind = require_filter.flowControllerFilterKind;
+exports.flowControllerKind = require_base.flowControllerKind;
+exports.flowControllerRetryKind = require_retry.flowControllerRetryKind;
+exports.flowControllerThrottlingKind = require_throttling.flowControllerThrottlingKind;
+exports.flowControllerTimeoutKind = require_timeout.flowControllerTimeoutKind;
+Object.defineProperty(exports, "invocation_exports", {
+	enumerable: true,
+	get: function() {
+		return invocation_exports;
+	}
+});
+exports.portHandlerKind = require_port.portHandlerKind;
+exports.retry = require_retry.retry;
+exports.throttling = require_throttling.throttling;
+exports.timeout = require_timeout.timeout;
+exports.useCaseHandlerKind = require_useCase.useCaseHandlerKind;
+exports.wireUseCases = require_useCase.wireUseCases;

package/dist/invocation/index.d.ts

@@ -0,0 +1,5 @@
+export * from './evidence';
+export * from './flow';
+export * from './kind';
+export * from './port';
+export * from './useCase';

package/dist/invocation/index.mjs

@@ -0,0 +1,39 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { appendEvidence, evidenceResult } from "./evidence.mjs";
+import { createKind } from "./kind.mjs";
+import { createFlowController, flowControllerExitKind, flowControllerKind } from "./flow/controller/base.mjs";
+import { debounce, flowControllerDebounceKind } from "./flow/controller/defaults/debounce.mjs";
+import { filter, flowControllerFilterKind } from "./flow/controller/defaults/filter.mjs";
+import { flowControllerRetryKind, retry } from "./flow/controller/defaults/retry.mjs";
+import { flowControllerThrottlingKind, throttling } from "./flow/controller/defaults/throttling.mjs";
+import { flowControllerTimeoutKind, timeout } from "./flow/controller/defaults/timeout.mjs";
+import { flow } from "./flow/base.mjs";
+import { createPort, portHandlerKind } from "./port.mjs";
+import { createUseCase, useCaseHandlerKind, wireUseCases } from "./useCase.mjs";
+//#region scripts/invocation/index.ts
+var invocation_exports = /* @__PURE__ */ __exportAll({
+	appendEvidence: () => appendEvidence,
+	createFlowController: () => createFlowController,
+	createKind: () => createKind,
+	createPort: () => createPort,
+	createUseCase: () => createUseCase,
+	debounce: () => debounce,
+	evidenceResult: () => evidenceResult,
+	filter: () => filter,
+	flow: () => flow,
+	flowControllerDebounceKind: () => flowControllerDebounceKind,
+	flowControllerExitKind: () => flowControllerExitKind,
+	flowControllerFilterKind: () => flowControllerFilterKind,
+	flowControllerKind: () => flowControllerKind,
+	flowControllerRetryKind: () => flowControllerRetryKind,
+	flowControllerThrottlingKind: () => flowControllerThrottlingKind,
+	flowControllerTimeoutKind: () => flowControllerTimeoutKind,
+	portHandlerKind: () => portHandlerKind,
+	retry: () => retry,
+	throttling: () => throttling,
+	timeout: () => timeout,
+	useCaseHandlerKind: () => useCaseHandlerKind,
+	wireUseCases: () => wireUseCases
+});
+//#endregion
+export { appendEvidence, createFlowController, createKind, createPort, createUseCase, debounce, evidenceResult, filter, flow, flowControllerDebounceKind, flowControllerExitKind, flowControllerFilterKind, flowControllerKind, flowControllerRetryKind, flowControllerThrottlingKind, flowControllerTimeoutKind, invocation_exports, portHandlerKind, retry, throttling, timeout, useCaseHandlerKind, wireUseCases };

package/dist/invocation/kind.cjs

@@ -0,0 +1,4 @@
+//#region scripts/invocation/kind.ts
+const createKind = require("../kind/namespace.cjs").createNamespace("DuplojsLangInvocation");
+//#endregion
+exports.createKind = createKind;

package/dist/invocation/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from '../kind';
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('../string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsLangInvocation/${GenericName}`, GenericKindValue>>;

package/dist/invocation/kind.mjs

@@ -0,0 +1,5 @@
+import { createNamespace } from "../kind/namespace.mjs";
+//#region scripts/invocation/kind.ts
+const createKind = createNamespace("DuplojsLangInvocation");
+//#endregion
+export { createKind };

package/dist/invocation/port.cjs

@@ -0,0 +1,13 @@
+//#region scripts/invocation/port.ts
+const portHandlerKind = require("./kind.cjs").createKind("port-handler");
+function createPort() {
+	return {
+		createImplementation(implementation) {
+			return implementation;
+		},
+		[portHandlerKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.createPort = createPort;
+exports.portHandlerKind = portHandlerKind;

package/dist/invocation/port.d.ts

@@ -0,0 +1,6 @@
+import type * as DKind from '../kind';
+export declare const portHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/port-handler", unknown>>;
+export interface PortHandler<GenericPort extends unknown = unknown> extends DKind.Kind<typeof portHandlerKind> {
+    createImplementation(implementation: GenericPort): GenericPort;
+}
+export declare function createPort<GenericPort extends unknown>(): PortHandler<GenericPort>;

package/dist/invocation/port.mjs

@@ -0,0 +1,13 @@
+import { createKind } from "./kind.mjs";
+//#region scripts/invocation/port.ts
+const portHandlerKind = createKind("port-handler");
+function createPort() {
+	return {
+		createImplementation(implementation) {
+			return implementation;
+		},
+		[portHandlerKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { createPort, portHandlerKind };

package/dist/invocation/useCase.cjs

@@ -0,0 +1,26 @@
+const require_entries = require("../object/entries.cjs");
+const require_entry = require("../object/entry.cjs");
+const require_fromEntries = require("../object/fromEntries.cjs");
+const require_map = require("../array/map.cjs");
+const require_forward = require("../common/forward.cjs");
+const require_pipe = require("../common/pipe.cjs");
+const require_uncapitalize = require("../string/uncapitalize.cjs");
+//#region scripts/invocation/useCase.ts
+const useCaseHandlerKind = require("./kind.cjs").createKind("use-case-handler");
+function createUseCase(dependencies, getUseCase) {
+	return {
+		dependencies,
+		getUseCase: (injectedDependencies) => getUseCase(require_pipe.pipe(require_forward.forward(dependencies), require_entries.entries, require_map.map(([key, value]) => {
+			const formattedKey = require_uncapitalize.uncapitalize(key);
+			return require_entry.entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey] ? value.getUseCase(injectedDependencies) : injectedDependencies[formattedKey]);
+		}), require_fromEntries.fromEntries)),
+		[useCaseHandlerKind.runTimeKey]: null
+	};
+}
+function wireUseCases(useCases, ports) {
+	return require_pipe.pipe(useCases, require_entries.entries, require_map.map(([key, useCase]) => require_entry.entry(require_uncapitalize.uncapitalize(key), useCase.getUseCase(ports))), require_fromEntries.fromEntries);
+}
+//#endregion
+exports.createUseCase = createUseCase;
+exports.useCaseHandlerKind = useCaseHandlerKind;
+exports.wireUseCases = wireUseCases;

package/dist/invocation/useCase.d.ts

@@ -0,0 +1,28 @@
+import { PortHandler } from './port';
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+export type UseCaseDependencies = Record<string, UseCaseHandler | PortHandler>;
+export type UseCaseDependenciesValue<GenericDependencies extends UseCaseDependencies> = DCommon.SimplifyTopLevel<{
+    [Prop in keyof GenericDependencies as Uncapitalize<Extract<Prop, string>>]: GenericDependencies[Prop] extends PortHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+}>;
+export type GetAllPorts<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
+    [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends PortHandler ? [
+        Uncapitalize<Extract<Prop, string>>,
+        ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
+    ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllPorts<GenericDependenciesValue[Prop]["dependencies"]> : never);
+})[keyof GenericDependenciesValue] : never;
+export declare const useCaseHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/use-case-handler", unknown>>;
+export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies = any, GenericUseCase extends (input: any) => any = any> extends DKind.Kind<typeof useCaseHandlerKind> {
+    dependencies: GenericDependencies;
+    getUseCase(ports: DCommon.SimplifyTopLevel<(GetAllPorts<GenericDependencies> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never) & ({
+        [Prop in keyof GenericDependencies as GenericDependencies[Prop] extends UseCaseHandler ? Uncapitalize<Extract<Prop, string>> : never]?: GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    })>): GenericUseCase;
+}
+export declare function createUseCase<const GenericDependencies extends UseCaseDependencies, GenericUseCase extends (...args: any[]) => any>(dependencies: GenericDependencies, getUseCase: (dependenciesValue: UseCaseDependenciesValue<GenericDependencies>) => GenericUseCase): UseCaseHandler<GenericDependencies, GenericUseCase>;
+export declare function wireUseCases<GenericUseCases extends Record<string, UseCaseHandler>>(useCases: GenericUseCases, ports: DCommon.SimplifyTopLevel<DCommon.UnionToIntersection<{
+    [Prop in keyof GenericUseCases]: GetAllPorts<GenericUseCases[Prop]["dependencies"]> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never;
+}[keyof GenericUseCases]>>): UseCaseDependenciesValue<GenericUseCases>;