@das-org/dascode 0.0.31

package/dist/Cache-DyGeujxI.mjs

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+
+import { Cc as succeedNone, Gc as fromInputUnsafe, Jc as isFinite, Ll as failVoid, Lu as PipeInspectableProto, Nl as filterMap, Oc as updateContext, Qs as asSome, Sc as succeed, Tc as sync, Uu as withFiber, Vu as exitSucceed, Wl as succeed$1, Yc as isZero, bu as isSome, cc as fiberInterrupt, kc as void_, mc as forkUnsafe, qc as infinity, qs as ClockRef, rc as exitHasInterrupts, rl as toMillis, ru as merge, tc as contextWith, uc as fiberJoin, vu as isNone, xd as dual, yc as onExit } from "./Schema-DuQUv9rO.mjs";
+import { Ct as make$1, Et as size, St as get$1, Tt as set$1, wt as remove } from "./Path-BB53LP8h.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/Cache.js
+/**
+* Caches values loaded by an Effect lookup function.
+*
+* A cache stores successful and failed lookup results, shares an in-progress
+* lookup when multiple callers request the same missing key, and limits entries
+* by capacity and optional time-to-live rules. This module includes helpers for
+* reading, setting, refreshing, invalidating, and inspecting cache contents.
+*
+* @since 4.0.0
+*/
+const TypeId = "~effect/Cache";
+/**
+* Creates a cache with dynamic time-to-live based on the result and key.
+*
+* **When to use**
+*
+* Use when you need different cache entry lifetimes based on the lookup result
+* or key characteristics.
+*
+* **Details**
+*
+* The timeToLive function receives both the exit result and the key, allowing
+* for flexible TTL policies based on success/failure state and key characteristics.
+*
+* **Example** (Configuring dynamic time to live)
+*
+* ```ts
+* import { Cache, Effect, Exit } from "effect"
+*
+* // Cache with TTL based on computed value
+* const userCache = Effect.gen(function*() {
+*   const cache = yield* Cache.makeWith(
+*     (id: number) => Effect.succeed({ id, active: id % 2 === 0 }),
+*     {
+*       capacity: 1000,
+*       timeToLive(exit) {
+*         if (Exit.isSuccess(exit)) {
+*           const user = exit.value
+*           return user.active ? "1 hour" : "5 minutes"
+*         }
+*         return "30 seconds"
+*       }
+*     }
+*   )
+*
+*   return cache
+* })
+* ```
+*
+* @see {@link make} for a simpler cache constructor with a fixed time-to-live for all entries
+* @category constructors
+* @since 2.0.0
+*/
+const makeWith = (lookup, options) => contextWith((context) => {
+	const self = Object.create(Proto);
+	self.lookup = (key) => updateContext(lookup(key), (input) => merge(context, input));
+	self.map = make$1();
+	self.capacity = options.capacity;
+	self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
+	return succeed(self);
+});
+/**
+* Creates a cache with a fixed time-to-live for all entries.
+*
+* **Details**
+*
+* This is the basic cache constructor where all entries share the same TTL.
+* The lookup function will be called when a key is not found or has expired.
+*
+* **Example** (Creating a basic cache)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Basic cache with string keys
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make<string, number>({
+*     capacity: 100,
+*     lookup: (key) => Effect.succeed(key.length)
+*   })
+*
+*   const result1 = yield* Cache.get(cache, "hello")
+*   const result2 = yield* Cache.get(cache, "world")
+*   console.log({ result1, result2 }) // { result1: 5, result2: 5 }
+* })
+* ```
+*
+* **Example** (Creating a cache with TTL)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const users = new Map([
+*     [123, { name: "Ada", email: "ada@example.com" }],
+*     [456, { name: "Grace", email: "grace@example.com" }]
+*   ])
+*
+*   const cache = yield* Cache.make<
+*     number,
+*     { name: string; email: string },
+*     string
+*   >({
+*     capacity: 500,
+*     lookup: (userId) =>
+*       Effect.suspend(() => {
+*         const user = users.get(userId)
+*         return user === undefined
+*           ? Effect.fail(`User ${userId} not found`)
+*           : Effect.succeed(user)
+*       }),
+*     timeToLive: "15 minutes"
+*   })
+*
+*   const user1 = yield* Cache.get(cache, 123)
+*   console.log(user1) // { name: "Ada", email: "ada@example.com" }
+*
+*   const user2 = yield* Cache.get(cache, 123)
+*   console.log(user2) // { name: "Ada", email: "ada@example.com" }
+* })
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const make = (options) => makeWith(options.lookup, {
+	...options,
+	timeToLive: options.timeToLive ? () => options.timeToLive : defaultTimeToLive
+});
+const Proto = {
+	...PipeInspectableProto,
+	[TypeId]: TypeId,
+	toJSON() {
+		return {
+			_id: "Cache",
+			capacity: this.capacity,
+			map: this.map
+		};
+	}
+};
+const defaultTimeToLive = (_, _key) => infinity;
+/**
+* Retrieves the value for a key, invoking the lookup function on a cache miss
+* or expired entry.
+*
+* **Details**
+*
+* Concurrent `get` calls for the same missing key share the same pending
+* lookup. The cache stores the lookup `Exit`, so failed lookups are cached and
+* will fail again until the entry expires, is invalidated, or is refreshed.
+*
+* **Example** (Getting cached values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Cache miss - triggers lookup function
+*   const result1 = yield* Cache.get(cache, "hello")
+*   console.log(result1) // 5
+*
+*   // Cache hit - returns cached value without lookup
+*   const result2 = yield* Cache.get(cache, "hello")
+*   console.log(result2) // 5 (from cache)
+*
+*   return { result1, result2 }
+* })
+* ```
+*
+* **Example** (Handling lookup failures)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Error handling when lookup fails
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make<string, number, string>({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       key === "error"
+*         ? Effect.fail("Lookup failed")
+*         : Effect.succeed(key.length)
+*   })
+*
+*   // Successful lookup
+*   const success = yield* Cache.get(cache, "hello")
+*   console.log(success) // 5
+*
+*   // Failed lookup - returns error
+*   const failure = yield* Effect.exit(Cache.get(cache, "error"))
+*   console.log(failure) // Exit.fail("Lookup failed")
+* })
+* ```
+*
+* **Example** (Sharing concurrent lookups)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Concurrent access - multiple gets of same key only invoke lookup once
+* const program = Effect.gen(function*() {
+*   let lookupCount = 0
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       Effect.sync(() => {
+*         lookupCount++
+*         return key.length
+*       })
+*   })
+*
+*   // Multiple concurrent gets
+*   const results = yield* Effect.all([
+*     Cache.get(cache, "hello"),
+*     Cache.get(cache, "hello"),
+*     Cache.get(cache, "hello")
+*   ], { concurrency: "unbounded" })
+*
+*   console.log(results) // [5, 5, 5]
+*   console.log(lookupCount) // 1 (lookup called only once)
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const get = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const oentry = get$1(self.map, key);
+	if (isSome(oentry) && !hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		set$1(self.map, key, oentry.value);
+		return oentry.value.await();
+	}
+	const entry = new EntryImpl(fiber, self.lookup(key));
+	entry.fiber.addObserver((exit) => {
+		if (exitHasInterrupts(exit)) {
+			remove(self.map, key);
+			return;
+		}
+		const ttl = self.timeToLive(exit, key);
+		if (isFinite(ttl)) entry.expiresAt = fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl);
+		else if (isZero(ttl)) remove(self.map, key);
+	});
+	set$1(self.map, key, entry);
+	if (Number.isFinite(self.capacity)) checkCapacity(self);
+	return entry.await();
+}));
+var EntryImpl = class {
+	expiresAt;
+	awaiters;
+	fiber;
+	constructor(parent, valueEffect) {
+		this.fiber = forkUnsafe(parent, valueEffect, true, true);
+		this.awaiters = 0;
+		this.expiresAt = void 0;
+	}
+	await() {
+		const exit = this.fiber.pollUnsafe();
+		if (exit) return exit;
+		this.awaiters++;
+		return onExit(fiberJoin(this.fiber), () => {
+			this.awaiters--;
+			if (this.awaiters > 0 || this.fiber.pollUnsafe()) return void_;
+			return fiberInterrupt(this.fiber);
+		});
+	}
+};
+const hasExpired = (entry, fiber) => {
+	if (entry.expiresAt === void 0) return false;
+	return fiber.getRef(ClockRef).currentTimeMillisUnsafe() >= entry.expiresAt;
+};
+const checkCapacity = (self) => {
+	let diff = size(self.map) - self.capacity;
+	if (diff <= 0) return;
+	for (const [key] of self.map) {
+		remove(self.map, key);
+		diff--;
+		if (diff === 0) return;
+	}
+};
+/**
+* Reads an existing cache entry without invoking the lookup function.
+*
+* **Details**
+*
+* Returns `Option.none()` when the key is missing or expired, and `Option.some`
+* when a cached lookup has succeeded. If the entry is still pending, waits for
+* it to complete. If the cached or pending lookup fails, this effect fails with
+* the same error.
+*
+* **Example** (Reading cached values without lookup)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // No value in cache yet - returns None without lookup
+*   const empty = yield* Cache.getOption(cache, "hello")
+*   console.log(empty) // Option.none()
+*
+*   // Populate cache using get
+*   yield* Cache.get(cache, "hello")
+*
+*   // Now getOption returns the cached value
+*   const cached = yield* Cache.getOption(cache, "hello")
+*   console.log(cached) // Option.some(5)
+*
+*   return { empty, cached }
+* })
+* ```
+*
+* **Example** (Skipping expired entries)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // Expired entries return None
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Add value to cache
+*   yield* Cache.get(cache, "hello")
+*
+*   // Value exists before expiration
+*   const beforeExpiry = yield* Cache.getOption(cache, "hello")
+*   console.log(beforeExpiry) // Option.some(5)
+*
+*   // Simulate time passing
+*   yield* TestClock.adjust("2 hours")
+*
+*   // Value expired - returns None
+*   const afterExpiry = yield* Cache.getOption(cache, "hello")
+*   console.log(afterExpiry) // Option.none()
+* })
+* ```
+*
+* **Example** (Waiting for pending lookups)
+*
+* ```ts
+* import { Cache, Deferred, Effect, Fiber } from "effect"
+*
+* // Waits for ongoing computation to complete
+* const program = Effect.gen(function*() {
+*   const deferred = yield* Deferred.make<void>()
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (_key: string) => Deferred.await(deferred).pipe(Effect.as(42))
+*   })
+*
+*   // Start lookup in background
+*   const getFiber = yield* Effect.forkChild(Cache.get(cache, "key"))
+*
+*   // getOption waits for ongoing computation
+*   const optionFiber = yield* Effect.forkChild(Cache.getOption(cache, "key"))
+*
+*   // Complete the computation
+*   yield* Deferred.succeed(deferred, void 0)
+*
+*   const result = yield* Fiber.join(optionFiber)
+*   console.log(result) // Option.some(42)
+*
+*   const value = yield* Fiber.join(getFiber)
+*   console.log(value) // 42
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const getOption = /*#__PURE__*/ dual(2, (self, key) => withFiber((fiber) => {
+	const entry = getImpl(self, key, fiber);
+	return entry ? asSome(entry.await()) : succeedNone;
+}));
+const getImpl = (self, key, fiber, isRead = true) => {
+	const oentry = get$1(self.map, key);
+	if (isNone(oentry)) return;
+	else if (hasExpired(oentry.value, fiber)) {
+		remove(self.map, key);
+		return;
+	} else if (isRead) {
+		remove(self.map, key);
+		set$1(self.map, key, oentry.value);
+	}
+	return oentry.value;
+};
+/**
+* Sets the value associated with the specified key in the cache. This will
+* overwrite any existing value for that key, skipping the lookup function.
+*
+* **Example** (Setting values directly)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Set a value directly without invoking lookup
+*   yield* Cache.set(cache, "hello", 42)
+*   const result = yield* Cache.get(cache, "hello")
+*   console.log(result) // 42 (not 5 from lookup)
+* })
+* ```
+*
+* **Example** (Overwriting cached values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Overwriting existing cached values
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // First get populates via lookup
+*   const original = yield* Cache.get(cache, "test") // 4
+*
+*   // Set overwrites the cached value
+*   yield* Cache.set(cache, "test", 999)
+*   const updated = yield* Cache.get(cache, "test") // 999
+*
+*   console.log({ original, updated })
+* })
+* ```
+*
+* **Example** (Applying TTL to set values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* // TTL behavior with set operations
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 100,
+*     lookup: (key: string) => Effect.succeed(key.length),
+*     timeToLive: "1 hour"
+*   })
+*
+*   // Set value with TTL applied
+*   yield* Cache.set(cache, "temporary", 123)
+*   console.log(yield* Cache.has(cache, "temporary")) // true
+*
+*   // Advance time past TTL
+*   yield* TestClock.adjust("2 hours")
+*   console.log(yield* Cache.has(cache, "temporary")) // false
+* })
+* ```
+*
+* **Example** (Enforcing capacity when setting values)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Capacity enforcement with set operations
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 2,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Fill cache to capacity
+*   yield* Cache.set(cache, "a", 1)
+*   yield* Cache.set(cache, "b", 2)
+*   console.log(yield* Cache.size(cache)) // 2
+*
+*   // Adding another entry evicts oldest
+*   yield* Cache.set(cache, "c", 3)
+*   console.log(yield* Cache.size(cache)) // 2
+*   console.log(yield* Cache.has(cache, "a")) // false (evicted)
+*   console.log(yield* Cache.has(cache, "c")) // true
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const set = /*#__PURE__*/ dual(3, (self, key, value) => withFiber((fiber) => {
+	const exit = exitSucceed(value);
+	const entry = new EntryImpl(fiber, exit);
+	const ttl = self.timeToLive(exit, key);
+	if (isZero(ttl)) {
+		remove(self.map, key);
+		return void_;
+	}
+	entry.expiresAt = isFinite(ttl) ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl) : void 0;
+	set$1(self.map, key, entry);
+	checkCapacity(self);
+	return void_;
+}));
+/**
+* Invalidates the entry associated with the specified key in the cache.
+*
+* **Example** (Invalidating cached entries)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add a value to the cache
+*   yield* Cache.get(cache, "hello")
+*   console.log(yield* Cache.has(cache, "hello")) // true
+*
+*   // Invalidate the entry
+*   yield* Cache.invalidate(cache, "hello")
+*   console.log(yield* Cache.has(cache, "hello")) // false
+*
+*   // Invalidating non-existent keys doesn't error
+*   yield* Cache.invalidate(cache, "nonexistent")
+*
+*   // Get after invalidation will invoke lookup again
+*   let lookupCount = 0
+*   const cache2 = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) =>
+*       Effect.sync(() => {
+*         lookupCount++
+*         return key.length
+*       })
+*   })
+*
+*   yield* Cache.get(cache2, "test") // lookupCount = 1
+*   yield* Cache.invalidate(cache2, "test")
+*   yield* Cache.get(cache2, "test") // lookupCount = 2 (lookup called again)
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const invalidate = /*#__PURE__*/ dual(2, (self, key) => sync(() => {
+	remove(self.map, key);
+}));
+/**
+* Retrieves all active keys from the cache, automatically filtering out expired entries.
+*
+* **Example** (Reading active keys)
+*
+* ```ts
+* import { Cache, Effect } from "effect"
+*
+* // Basic key enumeration
+* const program = Effect.gen(function*() {
+*   const cache = yield* Cache.make({
+*     capacity: 10,
+*     lookup: (key: string) => Effect.succeed(key.length)
+*   })
+*
+*   // Add some entries to the cache
+*   yield* Cache.get(cache, "hello")
+*   yield* Cache.get(cache, "world")
+*   yield* Cache.get(cache, "cache")
+*
+*   // Retrieve all active keys
+*   const keys = yield* Cache.keys(cache)
+*
+*   console.log(Array.from(keys).sort()) // ["cache", "hello", "world"]
+* })
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+const keys = (self) => withFiber((fiber) => {
+	const now = fiber.getRef(ClockRef).currentTimeMillisUnsafe();
+	return succeed(filterMap(self.map, ([key, entry]) => {
+		if (entry.expiresAt === void 0 || entry.expiresAt > now) return succeed$1(key);
+		remove(self.map, key);
+		return failVoid;
+	}));
+});
+//#endregion
+export { make as a, keys as i, getOption as n, makeWith as o, invalidate as r, set as s, get as t };
+
+//# sourceMappingURL=Cache-DyGeujxI.mjs.map