@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/MutableHashMap-f8nW8AJR.mjs

@@ -0,0 +1,376 @@
+import { Bt as hash, Ct as NodeInspectSymbol, Et as format, It as equals, On as pipeArguments, S as none, _ as isSome, bn as dual, w as some, wt as toJson } from "./Option-DkxSnBhp.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/MutableHashMap.js
+const TypeId = "~effect/MutableHashMap";
+const MutableHashMapProto = {
+	[TypeId]: TypeId,
+	[Symbol.iterator]() {
+		return this.backing[Symbol.iterator]();
+	},
+	toString() {
+		return `MutableHashMap(${format(Array.from(this))})`;
+	},
+	toJSON() {
+		return {
+			_id: "MutableHashMap",
+			values: toJson(Array.from(this))
+		};
+	},
+	[NodeInspectSymbol]() {
+		return this.toJSON();
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Creates an empty MutableHashMap.
+*
+* **When to use**
+*
+* Use to create a fresh mutable map before adding entries over time.
+*
+* **Details**
+*
+* Each call returns a new empty map instance.
+*
+* **Example** (Creating an empty map)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap } from "effect"
+*
+* const map = MutableHashMap.empty<string, number>()
+*
+* // Add some entries
+* MutableHashMap.set(map, "key1", 42)
+* MutableHashMap.set(map, "key2", 100)
+*
+* MutableHashMap.size(map) // => 2
+* ```
+*
+* @see {@link make} for creating a map from explicit entries
+* @see {@link fromIterable} for creating a map from an iterable of entries
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const empty = () => {
+	const self = Object.create(MutableHashMapProto);
+	self.backing = /* @__PURE__ */ new Map();
+	self.buckets = /* @__PURE__ */ new Map();
+	return self;
+};
+/**
+* Looks up a key in the `MutableHashMap` safely.
+*
+* **When to use**
+*
+* Use to safely read a `MutableHashMap` value for a key as an `Option`.
+*
+* **Details**
+*
+* Returns `Some(value)` when an equal key is present and `None` when the key is
+* absent.
+*
+* **Example** (Getting a value)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap, Option } from "effect"
+*
+* const map = MutableHashMap.make(["key1", 42], ["key2", 100])
+*
+* MutableHashMap.get(map, "key1") // => Option.some(42)
+* MutableHashMap.get(map, "key3") // => Option.none()
+*
+* // Pipe-able version
+* MutableHashMap.get("key1")(map) // => Option.some(42)
+* ```
+*
+* @see {@link has} for checking only whether a key is present
+* @see {@link set} for inserting or replacing a value by key
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const get = /*#__PURE__*/ dual(2, (self, key) => {
+	if (self.backing.has(key)) return some(self.backing.get(key));
+	else if (isSimpleKey(key)) return none();
+	const hash$2 = hash(key);
+	const bucket = self.buckets.get(hash$2);
+	if (bucket === void 0) return none();
+	return getFromBucket(self, bucket, key);
+});
+const isSimpleKey = (u) => typeof u !== "object" && typeof u !== "function";
+/**
+* Returns an iterable over the values in the `MutableHashMap`.
+*
+* **When to use**
+*
+* Use to iterate over the values currently stored in a mutable hash map.
+*
+* **Example** (Reading values)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap } from "effect"
+*
+* const map = MutableHashMap.make(
+*   ["apple", 1],
+*   ["banana", 2],
+*   ["cherry", 3]
+* )
+*
+* const allValues = Array.from(MutableHashMap.values(map)) // => [1, 2, 3]
+*
+* // Useful for calculations
+* allValues.reduce((sum, value) => sum + value, 0) // => 6
+*
+* // Filter values
+* allValues.filter((value) => value > 1) // => [2, 3]
+* ```
+*
+* @see {@link keys} for iterating over stored keys
+*
+* @stability stable
+* @category getters
+* @since 3.8.0
+*/
+const values = (self) => self.backing.values();
+const getFromBucket = (self, bucket, key) => {
+	for (let i = 0, len = bucket.length; i < len; i++) if (equals(key, bucket[i])) {
+		const refKey = bucket[i];
+		return some(self.backing.get(refKey));
+	}
+	return none();
+};
+/**
+* Checks whether the MutableHashMap contains the specified key.
+*
+* **When to use**
+*
+* Use to test whether a key is present in a `MutableHashMap` without reading
+* its value.
+*
+* **Example** (Checking for a key)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap } from "effect"
+*
+* const map = MutableHashMap.make(["key1", 42], ["key2", 100])
+*
+* MutableHashMap.has(map, "key1") // => true
+* MutableHashMap.has(map, "key3") // => false
+*
+* // Pipe-able version
+* MutableHashMap.has("key1")(map) // => true
+* ```
+*
+* @see {@link get} for reading the value as an `Option`
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const has = /*#__PURE__*/ dual(2, (self, key) => isSome(get(self, key)));
+/**
+* Sets a key-value pair in the MutableHashMap, mutating the map in place.
+* If the key already exists, its value is updated.
+*
+* **When to use**
+*
+* Use to insert a new `MutableHashMap` entry or replace an existing entry in
+* place.
+*
+* **Example** (Setting key-value pairs)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap, Option } from "effect"
+*
+* const map = MutableHashMap.empty<string, number>()
+*
+* // Add new entries
+* MutableHashMap.set(map, "key1", 42)
+* MutableHashMap.set(map, "key2", 100)
+*
+* MutableHashMap.get(map, "key1") // => Option.some(42)
+* MutableHashMap.size(map) // => 2
+*
+* // Update existing entry
+* MutableHashMap.set(map, "key1", 999)
+* MutableHashMap.get(map, "key1") // => Option.some(999)
+*
+* // Pipe-able version
+* MutableHashMap.set("key3", 300)(map)
+* MutableHashMap.size(map) // => 3
+* ```
+*
+* @see {@link modify} for updating an existing value with a function
+* @see {@link modifyAt} for setting or removing based on the current optional value
+* @see {@link remove} for deleting an entry by key
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const set = /*#__PURE__*/ dual(3, (self, key, value) => {
+	if (self.backing.has(key) || isSimpleKey(key)) {
+		self.backing.set(key, value);
+		return self;
+	}
+	const hash$4 = hash(key);
+	const bucket = self.buckets.get(hash$4);
+	if (bucket === void 0) {
+		self.buckets.set(hash$4, [key]);
+		self.backing.set(key, value);
+		return self;
+	}
+	let refKey = getRefKey(bucket, key);
+	if (refKey === void 0) {
+		bucket.push(key);
+		refKey = key;
+	}
+	self.backing.set(refKey, value);
+	return self;
+});
+const getRefKey = (bucket, key) => {
+	for (let i = 0, len = bucket.length; i < len; i++) if (equals(key, bucket[i])) return bucket[i];
+};
+/**
+* Removes the specified key from the MutableHashMap, mutating the map in place.
+* If the key doesn't exist, the map remains unchanged.
+*
+* **When to use**
+*
+* Use to delete one key from a mutable hash map in place.
+*
+* **Example** (Removing a key)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap } from "effect"
+*
+* const map = MutableHashMap.make(
+*   ["key1", 42],
+*   ["key2", 100],
+*   ["key3", 200]
+* )
+*
+* MutableHashMap.size(map) // => 3
+*
+* // Remove existing key
+* MutableHashMap.remove(map, "key2")
+* MutableHashMap.size(map) // => 2
+* MutableHashMap.has(map, "key2") // => false
+*
+* // Remove non-existent key (no effect)
+* MutableHashMap.remove(map, "nonexistent")
+* MutableHashMap.size(map) // => 2
+*
+* // Pipe-able version
+* MutableHashMap.remove("key1")(map)
+* MutableHashMap.size(map) // => 1
+* ```
+*
+* @see {@link clear} for removing all entries
+* @see {@link modifyAt} for conditionally removing based on the current value
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const remove = /*#__PURE__*/ dual(2, (self, key_) => {
+	if (isSimpleKey(key_)) {
+		self.backing.delete(key_);
+		return self;
+	}
+	const hash$1 = hash(key_);
+	const bucket = self.buckets.get(hash$1);
+	if (bucket === void 0) return self;
+	for (let i = 0, len = bucket.length; i < len; i++) {
+		const bkey = bucket[i];
+		if (bkey === key_ || equals(key_, bkey)) {
+			self.backing.delete(bkey);
+			bucket.splice(i, 1);
+			break;
+		}
+	}
+	if (bucket.length === 0) self.buckets.delete(hash$1);
+	return self;
+});
+/**
+* Removes all key-value pairs from the MutableHashMap, mutating the map in place.
+* The map becomes empty after this operation.
+*
+* **When to use**
+*
+* Use to empty a mutable hash map while keeping the same map instance.
+*
+* **Example** (Clearing all entries)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap } from "effect"
+*
+* const map = MutableHashMap.make(
+*   ["key1", 42],
+*   ["key2", 100],
+*   ["key3", 200]
+* )
+*
+* MutableHashMap.size(map) // => 3
+*
+* // Clear all entries
+* MutableHashMap.clear(map)
+*
+* MutableHashMap.size(map) // => 0
+* MutableHashMap.has(map, "key1") // => false
+*
+* // Can still add new entries after clearing
+* MutableHashMap.set(map, "new", 999)
+* Array.from(map) // => [["new", 999]]
+* ```
+*
+* @see {@link remove} for deleting one key
+* @see {@link empty} for creating a fresh empty map
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const clear = (self) => {
+	self.backing.clear();
+	self.buckets.clear();
+	return self;
+};
+/**
+* Returns the number of key-value pairs in the MutableHashMap.
+*
+* **When to use**
+*
+* Use to read how many entries are currently stored in the mutable hash map.
+*
+* **Example** (Checking map size)
+*
+* ```ts import.meta.vitest
+* import { MutableHashMap } from "effect"
+*
+* const map = MutableHashMap.empty<string, number>()
+* MutableHashMap.size(map) // => 0
+*
+* MutableHashMap.set(map, "key1", 42)
+* MutableHashMap.set(map, "key2", 100)
+* MutableHashMap.size(map) // => 2
+*
+* MutableHashMap.remove(map, "key1")
+* MutableHashMap.size(map) // => 1
+*
+* MutableHashMap.clear(map)
+* MutableHashMap.size(map) // => 0
+* ```
+*
+* @see {@link isEmpty} for checking whether the map has no entries
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const size = (self) => self.backing.size;
+export { remove as a, values as c, has as i, empty as n, set as o, get as r, size as s, clear as t };

package/dist/MutableHashSet-_HI572Ya.mjs

@@ -0,0 +1,155 @@
+import { Ct as NodeInspectSymbol, Et as format, On as pipeArguments, bn as dual, wt as toJson } from "./Option-DkxSnBhp.mjs";
+import { i as has$1, n as empty$1, o as set } from "./MutableHashMap-f8nW8AJR.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/MutableHashSet.js
+/**
+* Stores unique values in a mutable hash set.
+*
+* `MutableHashSet` updates the same collection in place and supports fast
+* membership checks, insertion, removal, clearing, and iteration. It is built
+* on `MutableHashMap`: each set value is stored as a map key, so uniqueness
+* follows the same hashing and equality rules as the underlying mutable hash
+* map.
+*
+* @stability stable
+* @since 2.0.0
+*/
+const TypeId = "~effect/MutableHashSet";
+const MutableHashSetProto = {
+	[TypeId]: TypeId,
+	[Symbol.iterator]() {
+		return Array.from(this.keyMap).map(([_]) => _)[Symbol.iterator]();
+	},
+	toString() {
+		return `MutableHashSet(${format(Array.from(this))})`;
+	},
+	toJSON() {
+		return {
+			_id: "MutableHashSet",
+			values: toJson(Array.from(this))
+		};
+	},
+	[NodeInspectSymbol]() {
+		return this.toJSON();
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const fromHashMap = (keyMap) => {
+	const set = Object.create(MutableHashSetProto);
+	set.keyMap = keyMap;
+	return set;
+};
+/**
+* Creates an empty MutableHashSet.
+*
+* **When to use**
+*
+* Use to create a fresh mutable set before adding values over time.
+*
+* **Details**
+*
+* Each call returns a new empty set backed by an empty `MutableHashMap`.
+*
+* **Example** (Creating an empty set)
+*
+* ```ts import.meta.vitest
+* import { MutableHashSet } from "effect"
+*
+* const set = MutableHashSet.empty<string>()
+*
+* // Add some values
+* MutableHashSet.add(set, "apple")
+* MutableHashSet.add(set, "banana")
+* MutableHashSet.add(set, "apple") // Duplicate, no effect
+*
+* MutableHashSet.size(set) // => 2
+* Array.from(set) // => ["apple", "banana"]
+* ```
+*
+* @see {@link make} for creating a set from explicit values
+* @see {@link fromIterable} for creating a set from an iterable of values
+* @see {@link clear} for emptying an existing mutable set
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const empty = () => fromHashMap(empty$1());
+/**
+* Adds a value to the MutableHashSet, mutating the set in place.
+* If the value already exists, the set remains unchanged.
+*
+* **When to use**
+*
+* Use to insert a value into a mutable set while keeping uniqueness.
+*
+* **Example** (Adding values)
+*
+* ```ts import.meta.vitest
+* import { MutableHashSet } from "effect"
+*
+* const set = MutableHashSet.empty<string>()
+*
+* // Add new values
+* MutableHashSet.add(set, "apple")
+* MutableHashSet.add(set, "banana")
+*
+* MutableHashSet.size(set) // => 2
+* MutableHashSet.has(set, "apple") // => true
+*
+* // Add duplicate (no effect)
+* MutableHashSet.add(set, "apple")
+* MutableHashSet.size(set) // => 2
+*
+* // Pipe-able version
+* const addFruit = MutableHashSet.add("cherry")
+* addFruit(set)
+* MutableHashSet.size(set) // => 3
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const add = /*#__PURE__*/ dual(2, (self, key) => (set(self.keyMap, key, true), self));
+/**
+* Checks whether the MutableHashSet contains the specified value.
+*
+* **When to use**
+*
+* Use to test whether a mutable set currently contains a value.
+*
+* **Details**
+*
+* Membership follows the same hashing and equality rules as the underlying
+* `MutableHashMap`.
+*
+* **Example** (Checking for a value)
+*
+* ```ts import.meta.vitest
+* import { MutableHashSet } from "effect"
+*
+* const set = MutableHashSet.make("apple", "banana", "cherry")
+*
+* MutableHashSet.has(set, "apple") // => true
+* MutableHashSet.has(set, "grape") // => false
+*
+* // Pipe-able version
+* const hasApple = MutableHashSet.has("apple")
+* hasApple(set) // => true
+*
+* // Check after adding
+* MutableHashSet.add(set, "grape")
+* MutableHashSet.has(set, "grape") // => true
+* ```
+*
+* @see {@link add} for adding a value to the set
+* @see {@link remove} for removing a value from the set
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const has = /*#__PURE__*/ dual(2, (self, key) => has$1(self.keyMap, key));
+export { empty as n, has as r, add as t };

package/dist/MutableRef-D4Qv592C.mjs

@@ -0,0 +1,107 @@
+import { F as PipeInspectableProto, bn as dual, wt as toJson } from "./Option-DkxSnBhp.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/MutableRef.js
+const TypeId = "~effect/MutableRef";
+const MutableRefProto = {
+	[TypeId]: TypeId,
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "MutableRef",
+			current: toJson(this.current)
+		};
+	}
+};
+/**
+* Creates a new MutableRef with the specified initial value.
+*
+* **When to use**
+*
+* Use to create a synchronous `MutableRef` initialized with a value.
+*
+* **Example** (Creating mutable refs)
+*
+* ```ts import.meta.vitest
+* import { MutableRef } from "effect"
+*
+* // Create a counter reference
+* const counter = MutableRef.make(0)
+*
+* MutableRef.get(counter) // => 0
+*
+* // Create a configuration reference
+* const config = MutableRef.make({ debug: false, timeout: 5000 })
+*
+* MutableRef.get(config) // => { debug: false, timeout: 5000 }
+*
+* // Create a string reference
+* const status = MutableRef.make("idle")
+* MutableRef.set(status, "running")
+*
+* MutableRef.get(status) // => "running"
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make = (value) => {
+	const ref = Object.create(MutableRefProto);
+	ref.current = value;
+	return ref;
+};
+/**
+* Sets the MutableRef to a new value and returns the reference.
+*
+* **When to use**
+*
+* Use when you need an in-place `MutableRef` replacement that returns the same
+* `MutableRef`.
+*
+* **Example** (Setting values)
+*
+* ```ts import.meta.vitest
+* import { MutableRef } from "effect"
+*
+* const ref = MutableRef.make("initial")
+*
+* // Set a new value
+* MutableRef.set(ref, "updated")
+*
+* MutableRef.get(ref) // => "updated"
+*
+* // Chain set operations (since it returns the ref)
+* const result = MutableRef.set(ref, "final")
+*
+* result === ref // => true
+* MutableRef.get(ref) // => "final"
+*
+* // Set complex objects
+* const config = MutableRef.make({ debug: false, verbose: false })
+* MutableRef.set(config, { debug: true, verbose: true })
+*
+* MutableRef.get(config) // => { debug: true, verbose: true }
+*
+* // Pipe-able version
+* const setValue = MutableRef.set("new value")
+* setValue(ref)
+*
+* MutableRef.get(ref) // => "new value"
+*
+* // Useful for state management
+* const state = MutableRef.make<"idle" | "loading" | "success" | "error">("idle")
+* MutableRef.set(state, "loading")
+* // ... perform async operation
+* MutableRef.set(state, "success")
+*
+* MutableRef.get(state) // => "success"
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const set = /*#__PURE__*/ dual(2, (self, value) => {
+	self.current = value;
+	return self;
+});
+export { set as n, make as t };