Erster Docker-Stand

_node_modules/effect/dist/dts/Cache.d.ts

@@ -0,0 +1,241 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Duration from "./Duration.js";
+import type * as Effect from "./Effect.js";
+import type { Either } from "./Either.js";
+import type * as Exit from "./Exit.js";
+import type * as Option from "./Option.js";
+import type * as Predicate from "./Predicate.js";
+import type * as Types from "./Types.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export declare const CacheTypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type CacheTypeId = typeof CacheTypeId;
+/**
+ * @since 3.6.4
+ * @category symbols
+ */
+export declare const ConsumerCacheTypeId: unique symbol;
+/**
+ * @since 3.6.4
+ * @category symbols
+ */
+export type ConsumerCacheTypeId = typeof ConsumerCacheTypeId;
+/**
+ * A `Cache` is defined in terms of a lookup function that, given a key of
+ * type `Key`, can either fail with an error of type `Error` or succeed with a
+ * value of type `Value`. Getting a value from the cache will either return
+ * the previous result of the lookup function if it is available or else
+ * compute a new result with the lookup function, put it in the cache, and
+ * return it.
+ *
+ * A cache also has a specified capacity and time to live. When the cache is
+ * at capacity the least recently accessed values in the cache will be
+ * removed to make room for new values. Getting a value with a life older than
+ * the specified time to live will result in a new value being computed with
+ * the lookup function and returned when available.
+ *
+ * The cache is safe for concurrent access. If multiple fibers attempt to get
+ * the same key the lookup function will only be computed once and the result
+ * will be returned to all fibers.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Cache<in out Key, in out Value, out Error = never> extends ConsumerCache<Key, Value, Error>, Cache.Variance<Key, Value, Error> {
+    /**
+     * Retrieves the value associated with the specified key if it exists.
+     * Otherwise computes the value with the lookup function, puts it in the
+     * cache, and returns it.
+     */
+    get(key: Key): Effect.Effect<Value, Error>;
+    /**
+     * Retrieves the value associated with the specified key if it exists as a left.
+     * Otherwise computes the value with the lookup function, puts it in the
+     * cache, and returns it as a right.
+     */
+    getEither(key: Key): Effect.Effect<Either<Value, Value>, Error>;
+    /**
+     * Computes the value associated with the specified key, with the lookup
+     * function, and puts it in the cache. The difference between this and
+     * `get` method is that `refresh` triggers (re)computation of the value
+     * without invalidating it in the cache, so any request to the associated
+     * key can still be served while the value is being re-computed/retrieved
+     * by the lookup function. Additionally, `refresh` always triggers the
+     * lookup function, disregarding the last `Error`.
+     */
+    refresh(key: Key): Effect.Effect<void, Error>;
+    /**
+     * Associates the specified value with the specified key in the cache.
+     */
+    set(key: Key, value: Value): Effect.Effect<void>;
+}
+/**
+ * A ConsumerCache models a portion of a cache which is safe to share without allowing to create new values or access existing ones.
+ *
+ * It can be used safely to give over control for request management without leaking writer side details.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface ConsumerCache<in out Key, out Value, out Error = never> extends Cache.ConsumerVariance<Key, Value, Error> {
+    /**
+     * Retrieves the value associated with the specified key if it exists.
+     * Otherwise returns `Option.none`.
+     */
+    getOption(key: Key): Effect.Effect<Option.Option<Value>, Error>;
+    /**
+     * Retrieves the value associated with the specified key if it exists and the
+     * lookup function has completed. Otherwise returns `Option.none`.
+     */
+    getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>>;
+    /**
+     * Returns statistics for this cache.
+     */
+    readonly cacheStats: Effect.Effect<CacheStats>;
+    /**
+     * Returns whether a value associated with the specified key exists in the
+     * cache.
+     */
+    contains(key: Key): Effect.Effect<boolean>;
+    /**
+     * Returns statistics for the specified entry.
+     */
+    entryStats(key: Key): Effect.Effect<Option.Option<EntryStats>>;
+    /**
+     * Invalidates the value associated with the specified key.
+     */
+    invalidate(key: Key): Effect.Effect<void>;
+    /**
+     * Invalidates the value associated with the specified key if the predicate holds.
+     */
+    invalidateWhen(key: Key, predicate: Predicate.Predicate<Value>): Effect.Effect<void>;
+    /**
+     * Invalidates all values in the cache.
+     */
+    readonly invalidateAll: Effect.Effect<void>;
+    /**
+     * Returns the approximate number of values in the cache.
+     */
+    readonly size: Effect.Effect<number>;
+    /**
+     * Returns an approximation of the values in the cache.
+     */
+    readonly keys: Effect.Effect<Array<Key>>;
+    /**
+     * Returns an approximation of the values in the cache.
+     */
+    readonly values: Effect.Effect<Array<Value>>;
+    /**
+     * Returns an approximation of the values in the cache.
+     */
+    readonly entries: Effect.Effect<Array<[Key, Value]>>;
+}
+/**
+ * @since 2.0.0
+ */
+export declare namespace Cache {
+    /**
+     * @since 2.0.0
+     * @category models
+     */
+    interface Variance<in out Key, in out Value, out Error> {
+        readonly [CacheTypeId]: {
+            readonly _Key: Types.Invariant<Key>;
+            readonly _Error: Types.Covariant<Error>;
+            readonly _Value: Types.Invariant<Value>;
+        };
+    }
+    /**
+     * @since 3.6.4
+     * @category models
+     */
+    interface ConsumerVariance<in out Key, out Value, out Error> {
+        readonly [ConsumerCacheTypeId]: {
+            readonly _Key: Types.Invariant<Key>;
+            readonly _Error: Types.Covariant<Error>;
+            readonly _Value: Types.Covariant<Value>;
+        };
+    }
+}
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: <Key, Value, Error = never, Environment = never>(options: {
+    readonly capacity: number;
+    readonly timeToLive: Duration.DurationInput;
+    readonly lookup: Lookup<Key, Value, Error, Environment>;
+}) => Effect.Effect<Cache<Key, Value, Error>, never, Environment>;
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function, where the time to live can depend on the `Exit` value
+ * returned by the lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const makeWith: <Key, Value, Error = never, Environment = never>(options: {
+    readonly capacity: number;
+    readonly lookup: Lookup<Key, Value, Error, Environment>;
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput;
+}) => Effect.Effect<Cache<Key, Value, Error>, never, Environment>;
+/**
+ * `CacheStats` represents a snapshot of statistics for the cache as of a
+ * point in time.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface CacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly size: number;
+}
+/**
+ * Constructs a new `CacheStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const makeCacheStats: (options: {
+    readonly hits: number;
+    readonly misses: number;
+    readonly size: number;
+}) => CacheStats;
+/**
+ * Represents a snapshot of statistics for an entry in the cache.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface EntryStats {
+    readonly loadedMillis: number;
+}
+/**
+ * Constructs a new `EntryStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const makeEntryStats: (loadedMillis: number) => EntryStats;
+/**
+ * A `Lookup` represents a lookup function that, given a key of type `Key`, can
+ * return an effect that will either produce a value of type `Value` or fail
+ * with an error of type `Error` using an environment of type `Environment`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type Lookup<Key, Value, Error = never, Environment = never> = (key: Key) => Effect.Effect<Value, Error, Environment>;
+//# sourceMappingURL=Cache.d.ts.map