@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Match-CGPLZYrV.mjs

@@ -0,0 +1,434 @@
+import { On as pipeArguments, Sn as identity } from "./Option-DkxSnBhp.mjs";
+import { Y as fail, at as succeed, et as isResult, tt as isSuccess } from "./Array-B4kuTQeW.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/matcher.js
+/** @internal */
+const TypeId = "~effect/Match/Matcher";
+const TypeMatcherProto = {
+	[TypeId]: {
+		_input: identity,
+		_filters: identity,
+		_remaining: identity,
+		_result: identity,
+		_return: identity,
+		_args: identity
+	},
+	_tag: "TypeMatcher",
+	add(_case) {
+		return makeTypeMatcher(this.select, [...this.cases, _case]);
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+function makeTypeMatcher(select, cases) {
+	const matcher = Object.create(TypeMatcherProto);
+	matcher.select = select;
+	matcher.cases = cases;
+	return matcher;
+}
+const ValueMatcherProto = {
+	[TypeId]: {
+		_input: identity,
+		_filters: identity,
+		_result: identity,
+		_return: identity,
+		_flavor: identity
+	},
+	_tag: "ValueMatcher",
+	add(_case) {
+		if (isSuccess(this.value)) return this;
+		if (_case._tag === "When" && _case.guard(this.provided) === true) return makeValueMatcher(this.provided, succeed(_case.evaluate(this.provided)));
+		else if (_case._tag === "Not" && _case.guard(this.provided) === false) return makeValueMatcher(this.provided, succeed(_case.evaluate(this.provided)));
+		return this;
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+function makeValueMatcher(provided, value) {
+	const matcher = Object.create(ValueMatcherProto);
+	matcher.provided = provided;
+	matcher.value = value;
+	return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+	_tag: "When",
+	guard,
+	evaluate
+});
+/** @internal */
+const type$1 = () => makeTypeMatcher(identity, []);
+/** @internal */
+const value$1 = (i) => makeValueMatcher(i, fail(i));
+/** @internal */
+const discriminator = (field) => (...pattern) => {
+	const f = pattern[pattern.length - 1];
+	const values = pattern.slice(0, -1);
+	const pred = values.length === 1 ? (_) => _ != null && _[field] === values[0] : (_) => _ != null && values.includes(_[field]);
+	return (self) => self.add(makeWhen(pred, f));
+};
+/** @internal */
+const discriminators = (field) => (fields) => {
+	const predicate = makeWhen((arg) => arg != null && Object.hasOwn(fields, arg[field]), (data) => fields[data[field]](data));
+	return (self) => self.add(predicate);
+};
+/** @internal */
+const discriminatorsExhaustive$1 = (field) => (fields) => {
+	const addCases = discriminators(field)(fields);
+	return (matcher) => exhaustive$1(addCases(matcher));
+};
+/** @internal */
+const tag$1 = /*#__PURE__*/ discriminator("_tag");
+/** @internal */
+const tags$1 = /*#__PURE__*/ discriminators("_tag");
+/** @internal */
+const orElse$1 = (f) => (self) => {
+	const toResult = result(self);
+	if (isResult(toResult)) return toResult._tag === "Success" ? toResult.success : f(toResult.failure);
+	return (...args) => {
+		const a = toResult(...args);
+		return isSuccess(a) ? a.success : f(a.failure, ...args);
+	};
+};
+/** @internal */
+const result = (self) => {
+	if (self._tag === "ValueMatcher") return self.value;
+	const len = self.cases.length;
+	if (len === 1) {
+		const _case = self.cases[0];
+		return (...args) => {
+			const input = self.select(...args);
+			if (_case._tag === "When" && _case.guard(input) === true) return succeed(_case.evaluate(input, ...args));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return succeed(_case.evaluate(input, ...args));
+			return fail(input);
+		};
+	}
+	return (...args) => {
+		const input = self.select(...args);
+		for (let i = 0; i < len; i++) {
+			const _case = self.cases[i];
+			if (_case._tag === "When" && _case.guard(input) === true) return succeed(_case.evaluate(input, ...args));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return succeed(_case.evaluate(input, ...args));
+		}
+		return fail(input);
+	};
+};
+const getExhaustiveAbsurdErrorMessage = "effect/match/Match/exhaustive: absurd";
+/** @internal */
+const exhaustive$1 = (self) => {
+	const toResult = result(self);
+	if (isResult(toResult)) {
+		if (isSuccess(toResult)) return toResult.success;
+		throw new Error(getExhaustiveAbsurdErrorMessage);
+	}
+	return (...args) => {
+		const result = toResult(...args);
+		if (isSuccess(result)) return result.success;
+		throw new Error(getExhaustiveAbsurdErrorMessage);
+	};
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Match.js
+/**
+* Builds pattern matchers for TypeScript values.
+*
+* `Match` lets you add ordered cases and then finish them with a result,
+* fallback, `Option`, or exhaustive check. Use `Match.type` to define a
+* reusable matcher for a type, or `Match.value` to match one value immediately.
+* Cases can match literal values, predicates, object shapes, tags, negated
+* patterns, and common checks such as strings, numbers, records, and class
+* instances.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Creates a matcher for a specific type.
+*
+* **When to use**
+*
+* Use to build a reusable matcher function for values of a known input type.
+*
+* **Details**
+*
+* This function defines a `Matcher` that operates on a given type, allowing you
+* to specify conditions for handling different cases. Once the matcher is
+* created, you can use pattern-matching functions like {@link when} to define
+* how different values should be processed.
+*
+* **Example** (Matching Numbers and Strings)
+*
+* ```ts import.meta.vitest
+* import { Match } from "effect"
+*
+* // Create a matcher for values that are either strings or numbers
+* //
+* //      ┌─── (u: string | number) => string
+* //      ▼
+* const match = Match.type<string | number>().pipe(
+*   // Match when the value is a number
+*   Match.when(Match.number, (n) => `number: ${n}`),
+*   // Match when the value is a string
+*   Match.when(Match.string, (s) => `string: ${s}`),
+*   // Ensure all possible cases are handled
+*   Match.exhaustive
+* )
+*
+* match(0) // => "number: 0"
+*
+* match("hello") // => "string: hello"
+* ```
+*
+* @see {@link value} for creating a matcher from a specific value.
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const type = type$1;
+/**
+* Creates a matcher from a specific value.
+*
+* **When to use**
+*
+* Use to match one concrete input immediately.
+*
+* **Details**
+*
+* This function allows you to define a `Matcher` directly from a given value,
+* rather than from a type. This is useful when working with known values,
+* enabling structured pattern matching on objects, primitives, or any data
+* structure.
+*
+* Once the matcher is created, you can use pattern-matching functions like
+* {@link when} to define how different cases should be handled.
+*
+* **Example** (Matching an Object by Property)
+*
+* ```ts import.meta.vitest
+* import { Match } from "effect"
+*
+* const input = { name: "John", age: 30 }
+*
+* // Create a matcher for the specific object
+* const result = Match.value(input).pipe(
+*   // Match when the 'name' property is "John"
+*   Match.when(
+*     { name: "John" },
+*     (user) => `${user.name} is ${user.age} years old`
+*   ),
+*   // Provide a fallback if no match is found
+*   Match.orElse(() => "Oh, not John")
+* )
+*
+* result // => "John is 30 years old"
+* ```
+*
+* @see {@link type} for creating a matcher from a specific type.
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const value = value$1;
+/**
+* Matches values by a discriminator field and requires every possible case to
+* be handled.
+*
+* **When to use**
+*
+* Use to define an exhaustive discriminator handler map that finalizes the
+* matcher.
+*
+* **Details**
+*
+* This is the exhaustive variant of {@link discriminators}. Each possible
+* discriminator value must have a corresponding handler, so the matcher is
+* finalized directly and does not require `Match.exhaustive` at the end of the
+* pipeline.
+*
+* **Example** (Handling all discriminator cases)
+*
+* ```ts import.meta.vitest
+* import { Match, pipe } from "effect"
+*
+* const match = pipe(
+*   Match.type<
+*     { type: "A"; a: string } | { type: "B"; b: number } | {
+*       type: "C"
+*       c: boolean
+*     }
+*   >(),
+*   Match.discriminatorsExhaustive("type")({
+*     A: (a) => a.a,
+*     B: (b) => b.b,
+*     C: (c) => c.c
+*   })
+* )
+* match({ type: "C", c: true }) // => true
+* ```
+*
+* @see {@link discriminators} for defining discriminator handlers without finalizing the matcher
+*
+* @stability stable
+* @category defining patterns
+* @since 4.0.0
+*/
+const discriminatorsExhaustive = discriminatorsExhaustive$1;
+/**
+* Matches discriminated union members by their `_tag` field.
+*
+* **When to use**
+*
+* Use to handle one or more `_tag` cases with the same matcher branch.
+*
+* **Details**
+*
+* This helper follows the Effect convention that discriminated unions use
+* `"_tag"` as their discriminator field. Use {@link discriminator} for a
+* different discriminator field.
+*
+* **Example** (Matching a discriminated union by tag)
+*
+* ```ts import.meta.vitest
+* import { Match } from "effect"
+*
+* type Event =
+*   | { readonly _tag: "fetch" }
+*   | { readonly _tag: "success"; readonly data: string }
+*   | { readonly _tag: "error"; readonly error: Error }
+*   | { readonly _tag: "cancel" }
+*
+* const match = Match.type<Event>().pipe(
+*   // Match either "fetch" or "success"
+*   Match.tag("fetch", "success", () => `Ok!`),
+*   // Match "error" and extract the error message
+*   Match.tag("error", (event) => `Error: ${event.error.message}`),
+*   // Match "cancel"
+*   Match.tag("cancel", () => "Cancelled"),
+*   Match.exhaustive
+* )
+*
+* match({ _tag: "success", data: "Hello" }) // => "Ok!"
+*
+* match({ _tag: "error", error: new Error("Oops!") }) // => "Error: Oops!"
+* ```
+*
+* @stability stable
+* @category defining patterns
+* @since 4.0.0
+*/
+const tag = tag$1;
+/**
+* Matches values based on their `_tag` field, mapping each tag to a
+* corresponding handler.
+*
+* **Details**
+*
+* This function provides a way to handle discriminated unions by mapping `_tag`
+* values to specific functions. Each handler receives the matched value and
+* returns a transformed result. If all possible tags are handled, you can
+* enforce exhaustiveness using `Match.exhaustive` to ensure no case is missed.
+*
+* **Example** (Mapping tag handlers)
+*
+* ```ts import.meta.vitest
+* import { Match, pipe } from "effect"
+*
+* const match = pipe(
+*   Match.type<
+*     { _tag: "A"; a: string } | { _tag: "B"; b: number } | {
+*       _tag: "C"
+*       c: boolean
+*     }
+*   >(),
+*   Match.tags({
+*     A: (a) => a.a,
+*     B: (b) => b.b,
+*     C: (c) => c.c
+*   }),
+*   Match.exhaustive
+* )
+* match({ _tag: "A", a: "ok" }) // => "ok"
+* ```
+*
+* @stability stable
+* @category defining patterns
+* @since 4.0.0
+*/
+const tags = tags$1;
+/**
+* Provides a fallback value when no patterns match.
+*
+* **When to use**
+*
+* Use to finalize a matcher with a fallback for unmatched input.
+*
+* **Details**
+*
+* This function ensures that a matcher always returns a valid result, even if
+* no defined patterns match. It acts as a default case, similar to the
+* `default` clause in a `switch` statement or the final `else` in an `if-else`
+* chain.
+*
+* **Example** (Providing a default value when no patterns match)
+*
+* ```ts import.meta.vitest
+* import { Match } from "effect"
+*
+* // Create a matcher for string or number values
+* const match = Match.type<string | number>().pipe(
+*   // Match when the value is "a"
+*   Match.when("a", () => "ok"),
+*   // Fallback when no patterns match
+*   Match.orElse(() => "fallback")
+* )
+*
+* match("a") // => "ok"
+*
+* match("b") // => "fallback"
+* ```
+*
+* @see {@link option} for finalizing unmatched input as `Option.none`
+* @see {@link result} for returning unmatched input as a `Result` failure
+* @see {@link orElseAbsurd} for finalizing when unmatched input should be impossible
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const orElse = orElse$1;
+/**
+* Completes a matcher that handles every remaining input case.
+*
+* **When to use**
+*
+* Use to require TypeScript to reject incomplete matcher definitions before the
+* matcher is turned into a function.
+*
+* **Details**
+*
+* If any case is still unmatched, the matcher does not type-check as
+* exhaustive.
+*
+* **Example** (Ensuring all cases are covered)
+*
+* ```ts import.meta.vitest
+* import { Match } from "effect"
+*
+* // Create a matcher for string or number values
+* const match = Match.type<string | number>().pipe(
+*   // Match when the value is a number
+*   Match.when(Match.number, (n) => `number: ${n}`),
+*   // Mark the match as exhaustive, ensuring all cases are handled
+*   // TypeScript will throw an error if any case is missing
+*   // @ts-expect-error Type 'string' is not assignable to type 'never'
+*   Match.exhaustive
+* )
+* ```
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const exhaustive = exhaustive$1;
+export { tags as a, tag as i, exhaustive as n, type as o, orElse as r, value as s, discriminatorsExhaustive as t };