@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Order-C1JC991I.mjs

@@ -0,0 +1,481 @@
+import { bn as dual } from "./Option-DkxSnBhp.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Order.js
+/**
+* Defines comparison functions for ordered values.
+*
+* An `Order<A>` compares two `A` values and returns whether the first is less
+* than, equal to, or greater than the second. Orders are used for sorting,
+* choosing minimum or maximum values, checking ranges, and building ordered data
+* structures. This module includes built-in orders, constructors for custom
+* orders, tools for reversing and combining comparisons, tuple and struct
+* helpers, comparison predicates, clamping, and reducer support.
+*
+* @stability stable
+* @since 2.0.0
+*/
+/**
+* Creates a new `Order` instance from a comparison function.
+*
+* **When to use**
+*
+* Use when you need a sorting rule not covered by the built-in orders or input
+* mapping helpers, and you can provide a total comparison.
+*
+* **Details**
+*
+* Uses reference equality (`===`) as a shortcut: if `self === that`, it returns
+* `0` without calling the comparison function. The comparison function should
+* return `-1`, `0`, or `1`, and the returned order satisfies total ordering
+* laws when the comparison function does.
+*
+* **Example** (Creating an Order)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const byAge = Order.make<{ name: string; age: number }>((self, that) => {
+*   if (self.age < that.age) return -1
+*   if (self.age > that.age) return 1
+*   return 0
+* })
+*
+* byAge({ name: "Alice", age: 30 }, { name: "Bob", age: 25 }) // => 1
+* byAge({ name: "Alice", age: 25 }, { name: "Bob", age: 30 }) // => -1
+* ```
+*
+* @see {@link mapInput} to transform an order by mapping the input type
+* @see {@link combine} to combine multiple orders
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+function make(compare) {
+	return (self, that) => self === that ? 0 : compare(self, that);
+}
+/**
+* Order instance for strings that compares them lexicographically using JavaScript's `<` operator.
+*
+* **When to use**
+*
+* Use when you need lexicographic string ordering.
+*
+* **Details**
+*
+* Uses lexicographic dictionary ordering. The empty string is less than any
+* non-empty string, and comparisons are case-sensitive.
+*
+* **Example** (Ordering strings)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* Order.String("apple", "banana") // => -1
+* Order.String("banana", "apple") // => 1
+* Order.String("apple", "apple") // => 0
+* ```
+*
+* @see {@link mapInput} to compare objects by a string property
+* @see {@link Struct} to combine with other orders for struct comparison
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const String = /*#__PURE__*/ make((self, that) => self < that ? -1 : 1);
+/**
+* Order instance for numbers that compares them numerically.
+*
+* **When to use**
+*
+* Use when you need numeric ordering for numbers.
+*
+* **Details**
+*
+* `0` is considered equal to `-0`. All `NaN` values are considered equal to
+* each other, and any `NaN` is considered less than any non-`NaN` number. All
+* other values use standard numeric comparison.
+*
+* **Example** (Ordering numbers)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* Order.Number(1, 1) // => 0
+* Order.Number(1, 2) // => -1
+* Order.Number(2, 1) // => 1
+*
+* Order.Number(0, -0) // => 0
+* Order.Number(NaN, 1) // => -1
+* ```
+*
+* @see {@link mapInput} to compare objects by a number property
+* @see {@link BigInt} for bigint comparisons
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const Number = /*#__PURE__*/ make((self, that) => {
+	if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;
+	if (globalThis.Number.isNaN(self)) return -1;
+	if (globalThis.Number.isNaN(that)) return 1;
+	return self < that ? -1 : 1;
+});
+/**
+* Order instance for booleans where `false` is considered less than `true`.
+*
+* **When to use**
+*
+* Use when you need boolean ordering where `false` comes before `true`.
+*
+* **Details**
+*
+* `false` is less than `true`, and equal values return `0`.
+*
+* **Example** (Ordering booleans)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* Order.Boolean(false, true) // => -1
+* Order.Boolean(true, false) // => 1
+* Order.Boolean(true, true) // => 0
+* ```
+*
+* @see {@link mapInput} to compare objects by a boolean property
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const Boolean = /*#__PURE__*/ make((self, that) => self < that ? -1 : 1);
+/**
+* Order instance for bigints that compares them numerically.
+*
+* **When to use**
+*
+* Use when you need numeric ordering for `bigint` values.
+*
+* **Details**
+*
+* Uses standard numeric comparison for bigint values and handles arbitrarily
+* large integers.
+*
+* **Example** (Ordering BigInts)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* Order.BigInt(1n, 2n) // => -1
+* Order.BigInt(2n, 1n) // => 1
+* Order.BigInt(1n, 1n) // => 0
+* ```
+*
+* @see {@link Number} for regular number comparisons
+* @see {@link mapInput} to compare objects by a bigint property
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const BigInt = /*#__PURE__*/ make((self, that) => self < that ? -1 : 1);
+/**
+* Combines two `Order` instances to create a new `Order` that first compares using the first `Order`,
+* and if the values are equal, then compares using the second `Order`.
+*
+* **When to use**
+*
+* Use when you need tie-breaking with exactly two orders.
+*
+* **Details**
+*
+* First applies the first order. If the result is non-zero, that result is
+* returned; otherwise, the second order is applied. The result is the first
+* non-zero comparison result, or `0` if both orders return `0`.
+*
+* **Example** (Combining two Orders)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const byAge = Order.mapInput(
+*   Order.Number,
+*   (person: { name: string; age: number }) => person.age
+* )
+* const byName = Order.mapInput(
+*   Order.String,
+*   (person: { name: string; age: number }) => person.name
+* )
+* const byAgeAndName = Order.combine(byAge, byName)
+*
+* const person1 = { name: "Alice", age: 30 }
+* const person2 = { name: "Bob", age: 30 }
+* const person3 = { name: "Charlie", age: 25 }
+*
+* byAgeAndName(person1, person2) // => -1
+* byAgeAndName(person1, person3) // => 1
+* ```
+*
+* @see {@link combineAll} to combine multiple orders from a collection
+* @see {@link mapInput} to transform orders to work with different types
+* @stability stable
+* @category combining
+* @since 2.0.0
+*/
+const combine = /*#__PURE__*/ dual(2, (self, that) => make((a1, a2) => {
+	const out = self(a1, a2);
+	if (out !== 0) return out;
+	return that(a1, a2);
+}));
+/**
+* Transforms an `Order` on type `A` into an `Order` on type `B` by providing a function that
+* maps values of type `B` to values of type `A`.
+*
+* **When to use**
+*
+* Use when you need to adapt an `Order` to compare a larger value by one
+* derived property.
+*
+* **Details**
+*
+* Applies the mapping function to both values before comparison. The mapping
+* function should be pure and not have side effects so the ordering properties
+* of the original order are preserved.
+*
+* **Example** (Mapping Input)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const byLength = Order.mapInput(Order.Number, (s: string) => s.length)
+*
+* byLength("a", "bb") // => -1
+* byLength("bb", "a") // => 1
+* byLength("aa", "bb") // => 0
+* ```
+*
+* @see {@link combine} to combine mapped orders for multi-criteria comparison
+* @see {@link Struct} to create orders for structs with multiple fields
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const mapInput = /*#__PURE__*/ dual(2, (self, f) => make((b1, b2) => self(f(b1), f(b2))));
+/**
+* Order instance for `Date` objects that compares them chronologically by their timestamp.
+*
+* **When to use**
+*
+* Use when you need chronological ordering for JavaScript date values.
+*
+* **Details**
+*
+* Compares dates by their underlying timestamp in milliseconds since the epoch.
+* Earlier dates are less than later dates. Invalid dates are compared through
+* their `getTime()` result.
+*
+* **Example** (Ordering Dates)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const date1 = new Date("2023-01-01")
+* const date2 = new Date("2023-01-02")
+*
+* Order.Date(date1, date2) // => -1
+* Order.Date(date2, date1) // => 1
+* Order.Date(date1, date1) // => 0
+* ```
+*
+* @see {@link mapInput} to compare objects by a date property
+* @stability stable
+* @category instances
+* @since 2.0.0
+*/
+const Date = /*#__PURE__*/ mapInput(Number, (date) => date.getTime());
+/**
+* Checks whether one value is strictly less than another according to the given order.
+*
+* **When to use**
+*
+* Use when you need a boolean less-than predicate using an `Order`.
+*
+* **Details**
+*
+* Returns `true` if the order returns `-1`, meaning the first value is less
+* than the second. Equal or greater values return `false`.
+*
+* **Example** (Checking less-than comparisons)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const isLessThanNumber = Order.isLessThan(Order.Number)
+*
+* isLessThanNumber(1, 2) // => true
+* isLessThanNumber(2, 1) // => false
+* isLessThanNumber(1, 1) // => false
+* ```
+*
+* @see {@link isLessThanOrEqualTo} for non-strict less than or equal
+* @see {@link isGreaterThan} for strict greater than
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isLessThan = (O) => dual(2, (self, that) => O(self, that) === -1);
+/**
+* Checks whether one value is strictly greater than another according to the given order.
+*
+* **When to use**
+*
+* Use when you need a boolean greater-than predicate using an `Order`.
+*
+* **Details**
+*
+* Returns `true` if the order returns `1`, meaning the first value is greater
+* than the second. Equal or lesser values return `false`.
+*
+* **Example** (Checking greater-than comparisons)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const isGreaterThanNumber = Order.isGreaterThan(Order.Number)
+*
+* isGreaterThanNumber(2, 1) // => true
+* isGreaterThanNumber(1, 2) // => false
+* isGreaterThanNumber(1, 1) // => false
+* ```
+*
+* @see {@link isGreaterThanOrEqualTo} for non-strict greater than or equal
+* @see {@link isLessThan} for strict less than
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isGreaterThan = (O) => dual(2, (self, that) => O(self, that) === 1);
+/**
+* Checks whether one value is less than or equal to another according to the given order.
+*
+* **When to use**
+*
+* Use when you need a boolean less-than-or-equal predicate using an `Order`.
+*
+* **Details**
+*
+* Returns `true` if the order returns `-1` or `0`, and returns `false` only if
+* the order returns `1`.
+*
+* **Example** (Checking less-than-or-equal comparisons)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const isLessThanOrEqualToNumber = Order.isLessThanOrEqualTo(Order.Number)
+*
+* isLessThanOrEqualToNumber(1, 2) // => true
+* isLessThanOrEqualToNumber(1, 1) // => true
+* isLessThanOrEqualToNumber(2, 1) // => false
+* ```
+*
+* @see {@link isLessThan} for strict less than
+* @see {@link isGreaterThan} for strict greater than
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isLessThanOrEqualTo = (O) => dual(2, (self, that) => O(self, that) !== 1);
+/**
+* Checks whether one value is greater than or equal to another according to the given order.
+*
+* **When to use**
+*
+* Use when you need a boolean greater-than-or-equal predicate using an
+* `Order`.
+*
+* **Details**
+*
+* Returns `true` if the order returns `1` or `0`, and returns `false` only if
+* the order returns `-1`.
+*
+* **Example** (Checking greater-than-or-equal comparisons)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const isGreaterThanOrEqualToNumber = Order.isGreaterThanOrEqualTo(Order.Number)
+*
+* isGreaterThanOrEqualToNumber(2, 1) // => true
+* isGreaterThanOrEqualToNumber(1, 1) // => true
+* isGreaterThanOrEqualToNumber(1, 2) // => false
+* ```
+*
+* @see {@link isGreaterThan} for strict greater than
+* @see {@link isLessThanOrEqualTo} for less than or equal
+* @stability stable
+* @category predicates
+* @since 4.0.0
+*/
+const isGreaterThanOrEqualTo = (O) => dual(2, (self, that) => O(self, that) !== -1);
+/**
+* Returns the minimum of two values according to the given order. If they are equal, returns the first argument.
+*
+* **When to use**
+*
+* Use when you need to select the smaller of two values according to an
+* `Order`.
+*
+* **Details**
+*
+* Returns the value that compares as less than or equal to the other value. If
+* values are equal, the first argument is returned.
+*
+* **Example** (Selecting the minimum value)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const minNumber = Order.min(Order.Number)
+*
+* minNumber(1, 2) // => 1
+* minNumber(2, 1) // => 1
+* minNumber(1, 1) // => 1
+* ```
+*
+* @see {@link max} for the maximum of two values
+* @see {@link clamp} to clamp a value between min and max
+* @stability stable
+* @category comparisons
+* @since 2.0.0
+*/
+const min = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
+/**
+* Returns the maximum of two values according to the given order. If they are equal, returns the first argument.
+*
+* **When to use**
+*
+* Use when you need to select the larger of two values according to an
+* `Order`.
+*
+* **Details**
+*
+* Returns the value that compares as greater than or equal to the other value.
+* If values are equal, the first argument is returned.
+*
+* **Example** (Selecting the maximum value)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const maxNumber = Order.max(Order.Number)
+*
+* maxNumber(1, 2) // => 2
+* maxNumber(2, 1) // => 2
+* maxNumber(1, 1) // => 1
+* ```
+*
+* @see {@link min} for the minimum of two values
+* @see {@link clamp} to clamp a value between min and max
+* @stability stable
+* @category comparisons
+* @since 2.0.0
+*/
+const max = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
+export { String as a, isGreaterThanOrEqualTo as c, make as d, mapInput as f, Number as i, isLessThan as l, min as m, Boolean as n, combine as o, max as p, Date as r, isGreaterThan as s, BigInt as t, isLessThanOrEqualTo as u };

package/dist/Path-Djdv_eF5.mjs

@@ -0,0 +1,130 @@
+import { aa as Service } from "./Effect-CKFpqbmw.mjs";
+import { S as none, w as some } from "./Option-DkxSnBhp.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Path.js
+/**
+* Provides path operations through the Effect environment.
+*
+* The `Path` service works with file system paths without tying code to one
+* concrete platform module. It exposes common operations such as joining,
+* normalizing, parsing, formatting, resolving, and converting paths to or from
+* file URLs. This module includes the service interface, parsed path type,
+* service tag, runtime marker, and built-in POSIX path layer.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Runtime type identifier used to mark implementations of the `Path` service.
+*
+* **Details**
+*
+* The marker is the exact string stored on `Path` service implementations.
+* Most code should depend on the `Path` service instead of inspecting this
+* value directly.
+*
+* @see {@link layer} for the built-in POSIX `Path` service layer
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/Path";
+/**
+* Service tag for accessing the current `Path` implementation.
+*
+* **When to use**
+*
+* Use when you need path operations supplied by an effect's environment.
+*
+* **Example** (Providing a custom Path service)
+*
+* ```ts import.meta.vitest
+* import { Effect, Layer, Path } from "effect"
+*
+* // Create a custom path implementation
+* const customPath = Path.make({
+*   sep: "/",
+*   basename: (path: string, suffix?: string) => {
+*     const base = path.split("/").pop() || ""
+*     return suffix && base.endsWith(suffix)
+*       ? base.slice(0, -suffix.length)
+*       : base
+*   },
+*   dirname: (path: string) => path.split("/").slice(0, -1).join("/") || "/",
+*   extname: (path: string) => {
+*     const match = path.match(/\.[^.]*$/)
+*     return match ? match[0] : ""
+*   },
+*   format: (pathObject) => {
+*     const dir = pathObject.dir || ""
+*     const name = pathObject.name || ""
+*     const ext = pathObject.ext || ""
+*     return dir ? `${dir}/${name}${ext}` : `${name}${ext}`
+*   },
+*   fromFileUrl: (url: URL) => Effect.succeed(url.pathname),
+*   isAbsolute: (path: string) => path.startsWith("/"),
+*   join: (...paths: ReadonlyArray<string>) => paths.join("/"),
+*   normalize: (path: string) => path.replace(/\/+/g, "/"),
+*   parse: (path: string) => ({
+*     root: path.startsWith("/") ? "/" : "",
+*     dir: path.split("/").slice(0, -1).join("/") || "/",
+*     base: path.split("/").pop() || "",
+*     ext: path.match(/\.[^.]*$/)?.[0] || "",
+*     name: path.split("/").pop()?.replace(/\.[^.]*$/, "") || ""
+*   }),
+*   relative: (from: string, to: string) => to.replace(from, ""),
+*   resolve: (...pathSegments: ReadonlyArray<string>) => pathSegments.join("/"),
+*   toFileUrl: (path: string) => Effect.succeed(new URL(`file://${path}`)),
+*   toNamespacedPath: (path: string) => path
+* })
+*
+* // Provide the path service
+* const customPathLayer = Layer.succeed(Path.Path)(customPath)
+*
+* const program = Effect.gen(function*() {
+*   const path = yield* Path.Path
+*   return path.join("home", "user", "file.txt")
+* })
+*
+* // Run with custom path implementation
+* Effect.runSync(Effect.provide(program, customPathLayer)) // => "home/user/file.txt"
+* ```
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const Path = /*#__PURE__*/ Service("effect/Path");
+/**
+* Creates a `Path` service from platform path operations.
+*
+* **When to use**
+*
+* Use to build a `Path` implementation, such as a platform layer or a test
+* double, without implementing the operations that can be derived from the
+* others.
+*
+* **Details**
+*
+* Adds the `Path` type marker and derives `resolveWithin` from the provided
+* `parse`, `resolve`, `relative`, `isAbsolute`, and `sep`, so containment
+* follows the same platform rules as those operations.
+*
+* @see {@link layer} for the built-in POSIX `Path` service layer
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (impl) => Path.of({
+	...impl,
+	[TypeId]: TypeId,
+	resolveWithin(root, input) {
+		if (impl.parse(input).root !== "") return none();
+		const base = impl.resolve(root);
+		const candidate = impl.resolve(base, input);
+		const relative = impl.relative(base, candidate);
+		return relative === ".." || relative.startsWith(`..${impl.sep}`) || impl.isAbsolute(relative) ? none() : some(candidate);
+	}
+});
+export { make as n, Path as t };