@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Redacted-RkJrG5Me.mjs

@@ -0,0 +1,160 @@
+import { Bt as hash, F as PipeInspectableProto, It as equals, Kt as symbol, Lt as symbol$1, cn as isString, qt as hasProperty } from "./Option-DkxSnBhp.mjs";
+import { ut as make$1 } from "./Array-B4kuTQeW.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/redacted.js
+/** @internal */
+const redactedRegistry = /*#__PURE__*/ new WeakMap();
+/** @internal */
+const value$1 = (self) => {
+	if (redactedRegistry.has(self)) return redactedRegistry.get(self);
+	else throw new Error("Unable to get redacted value" + (self.label ? ` with label: "${self.label}"` : ""));
+};
+/** @internal */
+const stringOrRedacted = (val) => typeof val === "string" ? val : value$1(val);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Redacted.js
+/**
+* Wraps sensitive values so normal output does not reveal them.
+*
+* A `Redacted<A>` shows a redacted placeholder in string, JSON, and inspection
+* output, while still storing the original value for trusted code that needs to
+* recover it. This helps reduce accidental leaks in logs and diagnostics. This
+* module includes constructors, runtime checks, value recovery, wiping of stored
+* values, and comparison helpers that avoid exposing the wrapped value at the
+* call site.
+*
+* @stability stable
+* @since 3.3.0
+*/
+const TypeId = "~effect/Redacted";
+/**
+* Returns `true` if a value is a `Redacted` wrapper.
+*
+* **When to use**
+*
+* Use to validate unknown input and narrow it to `Redacted`.
+*
+* **Details**
+*
+* When this function returns `true`, TypeScript narrows the value to
+* `Redacted<unknown>`.
+*
+* **Example** (Checking for redacted values)
+*
+* ```ts import.meta.vitest
+* import { Redacted } from "effect"
+*
+* const secret = Redacted.make("my-secret")
+* const plainString = "not-secret"
+*
+* Redacted.isRedacted(secret) // => true
+* Redacted.isRedacted(plainString) // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 3.3.0
+*/
+const isRedacted = (u) => hasProperty(u, TypeId);
+/**
+* Creates a `Redacted` wrapper for a sensitive value.
+*
+* **When to use**
+*
+* Use to wrap a sensitive value so normal string, JSON, and inspection output
+* is redacted.
+*
+* **Details**
+*
+* The wrapper redacts string, JSON, and inspection output to reduce accidental
+* disclosure. The original value remains retrievable with `Redacted.value`
+* until the wrapper is wiped or becomes unreachable.
+*
+* **Example** (Creating a redacted value)
+*
+* ```ts import.meta.vitest
+* import { Redacted } from "effect"
+*
+* const API_KEY = Redacted.make("1234567890")
+* String(API_KEY) // => "<redacted>"
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 3.3.0
+*/
+const make = (value, options) => {
+	const self = Object.create(Proto);
+	if (options?.label) self.label = options.label;
+	redactedRegistry.set(self, value);
+	return self;
+};
+const Proto = {
+	[TypeId]: { _A: (_) => _ },
+	label: void 0,
+	...PipeInspectableProto,
+	toJSON() {
+		return this.toString();
+	},
+	toString() {
+		return `<redacted${isString(this.label) ? ":" + this.label : ""}>`;
+	},
+	[symbol]() {
+		return hash(redactedRegistry.get(this));
+	},
+	[symbol$1](that) {
+		return isRedacted(that) && equals(redactedRegistry.get(this), redactedRegistry.get(that));
+	}
+};
+/**
+* Retrieves the original value from a `Redacted` instance. Use this function
+* with caution, as it exposes the sensitive data.
+*
+* **When to use**
+*
+* Use when you need the underlying sensitive value at a trusted boundary.
+*
+* **Example** (Retrieving a redacted value)
+*
+* ```ts import.meta.vitest
+* import { Redacted } from "effect"
+*
+* const API_KEY = Redacted.make("1234567890")
+*
+* Redacted.value(API_KEY) // => "1234567890"
+* ```
+*
+* @stability stable
+* @category getters
+* @since 3.3.0
+*/
+const value = value$1;
+/**
+* Generates an equivalence relation for `Redacted<A>` values based on an
+* equivalence relation for the underlying values `A`. This function is useful
+* for comparing `Redacted` instances without exposing their contents.
+*
+* **When to use**
+*
+* Use when you need to compare wrapped secrets through an approved equality
+* rule without exposing the underlying values at each comparison site.
+*
+* **Example** (Comparing redacted values)
+*
+* ```ts import.meta.vitest
+* import { Equivalence, Redacted } from "effect"
+*
+* const API_KEY1 = Redacted.make("1234567890")
+* const API_KEY2 = Redacted.make("1-34567890")
+* const API_KEY3 = Redacted.make("1234567890")
+*
+* const equivalence = Redacted.makeEquivalence(Equivalence.strictEqual<string>())
+*
+* equivalence(API_KEY1, API_KEY2) // => false
+* equivalence(API_KEY1, API_KEY3) // => true
+* ```
+*
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const makeEquivalence = (isEquivalent) => make$1((x, y) => isEquivalent(value(x), value(y)));
+export { stringOrRedacted as a, value as i, make as n, makeEquivalence as r, isRedacted as t };

package/dist/Ref-BIPOxJNH.mjs

@@ -0,0 +1,267 @@
+import { en as sync } from "./Effect-CKFpqbmw.mjs";
+import { F as PipeInspectableProto, Sn as identity, bn as dual } from "./Option-DkxSnBhp.mjs";
+import { n as set$1, t as make$1 } from "./MutableRef-D4Qv592C.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Ref.js
+/**
+* Stores fiber-safe mutable state inside Effect programs.
+*
+* A `Ref<A>` holds one value and exposes reads, writes, and atomic
+* transformations as effects, so state changes compose with Effect's
+* concurrency model. This module includes constructors, safe and unsafe reads,
+* set and get-and-set helpers, update and modify helpers, and conditional
+* update variants that leave the value unchanged when an `Option.none` result
+* is returned.
+*
+* @stability stable
+* @since 2.0.0
+*/
+const RefProto = {
+	["~effect/Ref"]: { _A: identity },
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "Ref",
+			ref: this.ref
+		};
+	}
+};
+/**
+* Creates a new Ref with the specified initial value (unsafe version).
+*
+* **When to use**
+*
+* Use when you need immediate synchronous construction and can guarantee
+* that creating the `Ref` outside of `Effect` is safe.
+*
+* **Gotchas**
+*
+* Prefer `Ref.make` for Effect-wrapped creation in Effect programs.
+*
+* **Example** (Creating a ref unsafely)
+*
+* ```ts import.meta.vitest
+* import { Ref } from "effect"
+*
+* const counter = Ref.makeUnsafe(0)
+* Ref.getUnsafe(counter) // => 0
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const makeUnsafe = (value) => {
+	const self = Object.create(RefProto);
+	self.ref = make$1(value);
+	return self;
+};
+/**
+* Creates a new Ref with the specified initial value.
+*
+* **When to use**
+*
+* Use to create a `Ref` for shared mutable state inside an Effect program.
+*
+* **Example** (Creating a ref)
+*
+* ```ts import.meta.vitest
+* import { Effect, Ref } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const ref = yield* Ref.make(42)
+*   return yield* Ref.get(ref)
+* })
+*
+* await Effect.runPromise(program) // => 42
+* ```
+*
+* @see {@link makeUnsafe} for synchronous construction outside Effect code
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make = (value) => sync(() => makeUnsafe(value));
+/**
+* Gets the current value of the Ref.
+*
+* **When to use**
+*
+* Use to read the current `Ref` value without changing it.
+*
+* **Example** (Getting the current value)
+*
+* ```ts import.meta.vitest
+* import { Effect, Ref } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const ref = yield* Ref.make(42)
+*   return yield* Ref.get(ref)
+* })
+*
+* await Effect.runPromise(program) // => 42
+* ```
+*
+* @see {@link set} for replacing the current value
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const get = (self) => sync(() => self.ref.current);
+/**
+* Sets the value of the Ref to the specified value.
+*
+* **When to use**
+*
+* Use to replace the current `Ref` value with a known value.
+*
+* **Example** (Setting a value)
+*
+* ```ts import.meta.vitest
+* import { Effect, Ref } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const ref = yield* Ref.make(0)
+*   yield* Ref.set(ref, 42)
+*   return yield* Ref.get(ref)
+* })
+*
+* const program2 = Effect.gen(function*() {
+*   const ref = yield* Ref.make(0)
+*   yield* Ref.set(ref, 100)
+*   return yield* Ref.get(ref)
+* })
+*
+* await Effect.runPromise(program) // => 42
+* await Effect.runPromise(program2) // => 100
+* ```
+*
+* @see {@link getAndSet} for setting while returning the previous value
+* @see {@link setAndGet} for setting while returning the new value
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const set = /*#__PURE__*/ dual(2, (self, value) => sync(() => set$1(self.ref, value)));
+/**
+* Modifies the value of the Ref atomically using the given function.
+*
+* **When to use**
+*
+* Use to compute both a separate return value and the next stored `Ref` value
+* in one atomic update.
+*
+* **Details**
+*
+* The function receives the current value and returns a tuple of
+* `[result, newValue]`. The Ref is updated with `newValue`, and `result` is
+* returned by the effect.
+*
+* **Example** (Modifying a value atomically)
+*
+* ```ts import.meta.vitest
+* import { Effect, Ref } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const counter = yield* Ref.make(10)
+*
+*   const result = yield* Ref.modify(counter, (n) => [
+*     `Previous value was ${n}`,
+*     n * 2
+*   ])
+*   const current = yield* Ref.get(counter)
+*   return [result, current]
+* })
+*
+* const program2 = Effect.gen(function*() {
+*   const state = yield* Ref.make({ count: 0, total: 0 })
+*   return yield* Ref.modify(state, (s) => [
+*     s.count,
+*     { count: s.count + 1, total: s.total + s.count + 1 }
+*   ])
+* })
+*
+* await Effect.runPromise(program) // => ["Previous value was 10", 20]
+* await Effect.runPromise(program2) // => 0
+* ```
+*
+* @see {@link updateAndGet} for returning the new stored value
+* @see {@link modifySome} for optionally updating while returning a separate result
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const modify = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
+	const [b, a] = f(self.ref.current);
+	self.ref.current = a;
+	return b;
+}));
+/**
+* Updates the value of the Ref atomically using the given function.
+*
+* **When to use**
+*
+* Use to apply a `Ref` state transition without returning a value.
+*
+* **Example** (Updating a value)
+*
+* ```ts import.meta.vitest
+* import { Effect, Ref } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const counter = yield* Ref.make(5)
+*
+*   yield* Ref.update(counter, (n) => n * 2)
+*   return yield* Ref.get(counter)
+* })
+*
+* const program2 = Effect.gen(function*() {
+*   const counter = yield* Ref.make(5)
+*   yield* Ref.update(counter, (n: number) => n + 10)
+*   return yield* Ref.get(counter)
+* })
+*
+* await Effect.runPromise(program) // => 10
+* await Effect.runPromise(program2) // => 15
+* ```
+*
+* @see {@link updateAndGet} for returning the new value
+* @see {@link getAndUpdate} for returning the previous value
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const update = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
+	self.ref.current = f(self.ref.current);
+}));
+/**
+* Gets the current value of the Ref synchronously (unsafe version).
+*
+* **When to use**
+*
+* Use when you need immediate synchronous access and can guarantee that
+* reading the `Ref` outside of `Effect` is safe.
+*
+* **Gotchas**
+*
+* Prefer `Ref.get` for Effect-wrapped access in Effect programs.
+*
+* **Example** (Reading a ref unsafely)
+*
+* ```ts import.meta.vitest
+* import { Ref } from "effect"
+*
+* const counter = Ref.makeUnsafe(42)
+* Ref.getUnsafe(counter) // => 42
+* ```
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const getUnsafe = (self) => self.ref.current;
+export { modify as a, makeUnsafe as i, getUnsafe as n, set as o, make as r, update as s, get as t };