@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/Console-BKHUkH6a.mjs

@@ -0,0 +1,141 @@
+import { mt as withFiber } from "./Option-DkxSnBhp.mjs";
+import { Gi as sync, ui as ConsoleRef } from "./Effect-CKFpqbmw.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Console.js
+/**
+* Context reference for the current console service in the Effect system, allowing access to the active console implementation from within the Effect context.
+*
+* **When to use**
+*
+* Use when you need an effect to run against a provided console implementation,
+* such as tests or alternate runtimes, rather than the default console.
+*
+* **Details**
+*
+* When no override is provided, the reference resolves to `globalThis.console`.
+*
+* **Example** (Accessing the current console)
+*
+* ```ts import.meta.vitest
+* import { Console, Effect } from "effect"
+*
+* const messages: Array<unknown> = []
+* const testConsole: Console.Console = Object.assign(Object.create(console), {
+*   log: (...args: ReadonlyArray<unknown>) => messages.push(...args)
+* })
+* const program = Console.consoleWith((console) =>
+*   Effect.sync(() => {
+*     console.log("Hello from current console!")
+*   })
+* )
+*
+* Effect.runSync(Effect.provideService(program, Console.Console, testConsole))
+* messages // => ["Hello from current console!"]
+* ```
+*
+* @see {@link consoleWith} for using the current console service inside an effect
+*
+* @stability stable
+* @category services
+* @since 2.0.0
+*/
+const Console = ConsoleRef;
+/**
+* Creates an Effect that provides access to the current console service and lets you perform operations with it within an Effect context.
+*
+* **Example** (Accessing the current console service)
+*
+* ```ts import.meta.vitest
+* import { Console, Effect } from "effect"
+*
+* const messages: Array<unknown> = []
+* const testConsole: Console.Console = Object.assign(Object.create(console), {
+*   log: (...args: ReadonlyArray<unknown>) => messages.push(...args),
+*   error: (...args: ReadonlyArray<unknown>) => messages.push(...args)
+* })
+* const program = Console.consoleWith((console) =>
+*   Effect.sync(() => {
+*     console.log("Hello, world!")
+*     console.error("This is an error message")
+*   })
+* )
+*
+* Effect.runSync(Effect.provideService(program, Console.Console, testConsole))
+* messages // => ["Hello, world!", "This is an error message"]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const consoleWith = (f) => withFiber((fiber) => f(fiber.getRef(Console)));
+/**
+* Writes an error-level message to the console, typically displayed with error
+* styling by the active console implementation.
+*
+* **Example** (Writing error messages)
+*
+* ```ts import.meta.vitest
+* import { Console, Effect } from "effect"
+*
+* const messages: Array<ReadonlyArray<unknown>> = []
+* const testConsole: Console.Console = Object.assign(Object.create(console), {
+*   error: (...args: ReadonlyArray<unknown>) => messages.push(args)
+* })
+* const program = Effect.gen(function*() {
+*   yield* Console.error("Something went wrong!")
+*   yield* Console.error("Error details:", {
+*     code: 500,
+*     message: "Internal Server Error"
+*   })
+* })
+*
+* Effect.runSync(Effect.provideService(program, Console.Console, testConsole))
+* const expected = [
+*   ["Something went wrong!"],
+*   ["Error details:", { code: 500, message: "Internal Server Error" }]
+* ]
+* messages // => expected
+* ```
+*
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const error = (...args) => consoleWith((console) => sync(() => {
+	console.error(...args);
+}));
+/**
+* Logs a general-purpose message to the console.
+*
+* **Example** (Writing log messages)
+*
+* ```ts import.meta.vitest
+* import { Console, Effect } from "effect"
+*
+* const messages: Array<ReadonlyArray<unknown>> = []
+* const testConsole: Console.Console = Object.assign(Object.create(console), {
+*   log: (...args: ReadonlyArray<unknown>) => messages.push(args)
+* })
+* const program = Effect.gen(function*() {
+*   yield* Console.log("Hello, world!")
+*   yield* Console.log("User data:", { name: "John", age: 30 })
+*   yield* Console.log("Processing", 42, "items")
+* })
+*
+* Effect.runSync(Effect.provideService(program, Console.Console, testConsole))
+* const expected = [
+*   ["Hello, world!"],
+*   ["User data:", { name: "John", age: 30 }],
+*   ["Processing", 42, "items"]
+* ]
+* messages // => expected
+* ```
+*
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const log = (...args) => consoleWith((console) => sync(() => {
+	console.log(...args);
+}));
+export { log as n, error as t };

package/dist/Data-CeCULr0-.mjs

@@ -0,0 +1,251 @@
+import { A as Error$1, En as Class$1, R as TaggedError$1, ht as assignProperties, un as isTagged } from "./Option-DkxSnBhp.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Data.js
+/**
+* Provides a base class for immutable data types.
+*
+* **When to use**
+*
+* Use when you need a lightweight immutable value type with `.pipe()` support.
+*
+* **Details**
+*
+* Extend `Class` with a type parameter to declare fields. The constructor
+* accepts those fields as a single object argument. When there are no fields
+* the argument is optional. Instances are `Readonly` and `Pipeable`.
+*
+* **Example** (Defining a value class)
+*
+* ```ts import.meta.vitest
+* import { Data, Equal } from "effect"
+*
+* class Person extends Data.Class<{ readonly name: string }> {}
+*
+* Equal.equals(new Person({ name: "Mike" }), new Person({ name: "Mike" })) // => true
+* ```
+*
+* @see {@link TaggedClass} — adds a `_tag` field
+* @see {@link Error} — yieldable error variant
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const Class = class extends Class$1 {
+	constructor(props) {
+		super();
+		if (props) assignProperties(this, props);
+	}
+};
+/**
+* Provides a base class for immutable data types with a `_tag` discriminator.
+*
+* **When to use**
+*
+* Use when you need a single-variant tagged type or an ad-hoc discriminator.
+*
+* **Details**
+*
+* Like {@link Class}, but the resulting instances also carry a
+* `readonly _tag: Tag` property. The `_tag` is excluded from the constructor
+* argument.
+*
+* **Example** (Defining a tagged class)
+*
+* ```ts import.meta.vitest
+* import { Data } from "effect"
+*
+* class Person extends Data.TaggedClass("Person")<{
+*   readonly name: string
+* }> {}
+*
+* new Person({ name: "Mike" })._tag // => "Person"
+* ```
+*
+* @see {@link Class} — without a `_tag`
+* @see {@link TaggedError} — tagged error variant
+* @see {@link TaggedEnum} — multi-variant unions
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const TaggedClass = (tag) => class extends Class {
+	_tag = tag;
+};
+/**
+* Creates constructors and matchers for a `TaggedEnum` type.
+*
+* **When to use**
+*
+* Use when you model a closed union with plain data objects and want
+* construction, tag checks, and exhaustive matching from the same definition.
+*
+* **Details**
+*
+* Returns an object with:
+* - One constructor per variant (keyed by tag name)
+* - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
+* - `$match` — exhaustive pattern matching (data-first or data-last)
+*
+* **Gotchas**
+*
+* - Constructors produce **plain objects**, not class instances.
+* - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
+*   on the tag being globally unique and the value being produced by your
+*   constructors. For untrusted input, validate with the `Schema` module first.
+*
+* **Example** (Creating and matching tagged enum values)
+*
+* ```ts import.meta.vitest
+* import { Data } from "effect"
+*
+* type HttpError = Data.TaggedEnum<{
+*   BadRequest: { readonly message: string }
+*   NotFound: { readonly url: string }
+* }>
+*
+* const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
+*
+* const err = NotFound({ url: "/missing" })
+*
+* $is("NotFound")(err) // => true
+*
+* $match(err, {
+*   BadRequest: (e) => e.message,
+*   NotFound: (e) => `${e.url} not found`
+* }) // => "/missing not found"
+* ```
+*
+* **Example** (Defining a generic tagged enum)
+*
+* ```ts import.meta.vitest
+* import { Data } from "effect"
+*
+* type MyResult<E, A> = Data.TaggedEnum<{
+*   Failure: { readonly error: E }
+*   Success: { readonly value: A }
+* }>
+* interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
+*   readonly taggedEnum: MyResult<this["A"], this["B"]>
+* }
+* const { Failure, Success } = Data.taggedEnum<MyResultDef>()
+*
+* const ok = Success({ value: 42 })
+* // ok: { readonly _tag: "Success"; readonly value: number }
+* ok // => { value: 42, _tag: "Success" }
+* ```
+*
+* @see {@link TaggedEnum} — the type-level companion
+* @see {@link TaggedEnum.Constructor} — the returned object type
+* @see {@link TaggedEnum.WithGenerics} — generic enum support
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const taggedEnum = () => new Proxy({}, { get(_target, tag, _receiver) {
+	if (tag === "$is") return isTagged;
+	else if (tag === "$match") return taggedMatch;
+	return (props) => ({
+		...props,
+		_tag: tag
+	});
+} });
+function taggedMatch() {
+	if (arguments.length === 1) {
+		const cases = arguments[0];
+		return function(value) {
+			return cases[value._tag](value);
+		};
+	}
+	const value = arguments[0];
+	return arguments[1][value._tag](value);
+}
+/**
+* Provides a base class for yieldable errors.
+*
+* **When to use**
+*
+* Use when you need yieldable errors that do **not** need tag-based
+* discrimination.
+*
+* **Details**
+*
+* Extends `Cause.YieldableError`, so instances can be yielded inside
+* `Effect.gen` to fail the enclosing effect. Fields are passed as a single
+* object; when there are no fields the argument is optional. If a `message`
+* field is provided, it becomes the error's `.message`.
+*
+* **Example** (Defining a yieldable error)
+*
+* ```ts import.meta.vitest
+* import { Data, Effect, Exit } from "effect"
+*
+* class NetworkError extends Data.Error<{
+*   readonly code: number
+*   readonly message: string
+* }> {}
+*
+* const program = Effect.gen(function*() {
+*   return yield* new NetworkError({ code: 500, message: "timeout" })
+* })
+*
+* Effect.runSync(Effect.exit(program)) // => Exit.fail(new NetworkError({ code: 500, message: "timeout" }))
+* ```
+*
+* @see {@link TaggedError} — adds a `_tag` for `Effect.catchTag`
+* @see {@link Class} — non-error data class
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const Error = Error$1;
+/**
+* Creates a tagged error class with a `_tag` discriminator.
+*
+* **When to use**
+*
+* Use when you need domain errors with discriminated-union handling.
+*
+* **Details**
+*
+* Like {@link Error}, but instances also carry a `readonly _tag` property,
+* enabling `Effect.catchTag` and `Effect.catchTags` for tag-based recovery.
+* The `_tag` is excluded from the constructor argument. Yielding an instance
+* inside `Effect.gen` fails the effect with this error.
+*
+* **Example** (Recovering by tag)
+*
+* ```ts import.meta.vitest
+* import { Data, Effect } from "effect"
+*
+* class NotFound extends Data.TaggedError("NotFound")<{
+*   readonly resource: string
+* }> {}
+*
+* class Forbidden extends Data.TaggedError("Forbidden")<{
+*   readonly reason: string
+* }> {}
+*
+* const program = Effect.gen(function*() {
+*   return yield* new NotFound({ resource: "/users/42" })
+* })
+*
+* const recovered = program.pipe(
+*   Effect.catchTag("NotFound", (e) =>
+*     Effect.succeed(`missing: ${e.resource}`))
+* )
+*
+* await Effect.runPromise(recovered) // => "missing: /users/42"
+* ```
+*
+* @see {@link Error} — without a `_tag`
+* @see {@link TaggedClass} — tagged class that is not an error
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const TaggedError = TaggedError$1;
+export { taggedEnum as a, TaggedError as i, Error as n, TaggedClass as r, Class as t };