effect 3.14.5 → 3.14.7

package/dist/esm/MutableHashSet.js

@@ -1,4 +1,95 @@
 /**
+ * # MutableHashSet
+ *
+ * A mutable `MutableHashSet` provides a collection of unique values with
+ * efficient lookup, insertion and removal. Unlike its immutable sibling
+ * {@link module:HashSet}, a `MutableHashSet` can be modified in-place;
+ * operations like add, remove, and clear directly modify the original set
+ * rather than creating a new one. This mutability offers benefits like improved
+ * performance in scenarios where you need to build or modify a set
+ * incrementally.
+ *
+ * ## What Problem Does It Solve?
+ *
+ * `MutableHashSet` solves the problem of maintaining an unsorted collection
+ * where each value appears exactly once, with fast operations for checking
+ * membership and adding/removing values, in contexts where mutability is
+ * preferred for performance or implementation simplicity.
+ *
+ * ## When to Use
+ *
+ * Use `MutableHashSet` when you need:
+ *
+ * - A collection with no duplicate values
+ * - Efficient membership testing (**`O(1)`** average complexity)
+ * - In-place modifications for better performance
+ * - A set that will be built or modified incrementally
+ * - Local mutability in otherwise immutable code
+ *
+ * ## Advanced Features
+ *
+ * MutableHashSet provides operations for:
+ *
+ * - Adding and removing elements with direct mutation
+ * - Checking for element existence
+ * - Clearing all elements at once
+ * - Converting to/from other collection types
+ *
+ * ## Performance Characteristics
+ *
+ * - **Lookup** operations ({@link module:MutableHashSet.has}): **`O(1)`** average
+ *   time complexity
+ * - **Insertion** operations ({@link module:MutableHashSet.add}): **`O(1)`**
+ *   average time complexity
+ * - **Removal** operations ({@link module:MutableHashSet.remove}): **`O(1)`**
+ *   average time complexity
+ * - **Iteration**: **`O(n)`** where n is the size of the set
+ *
+ * The MutableHashSet data structure implements the following traits:
+ *
+ * - {@link Iterable}: allows iterating over the values in the set
+ * - {@link Pipeable}: allows chaining operations with the pipe operator
+ * - {@link Inspectable}: allows inspecting the contents of the set
+ *
+ * ## Operations Reference
+ *
+ * | Category     | Operation                                  | Description                         | Complexity |
+ * | ------------ | ------------------------------------------ | ----------------------------------- | ---------- |
+ * | constructors | {@link module:MutableHashSet.empty}        | Creates an empty MutableHashSet     | O(1)       |
+ * | constructors | {@link module:MutableHashSet.fromIterable} | Creates a set from an iterable      | O(n)       |
+ * | constructors | {@link module:MutableHashSet.make}         | Creates a set from multiple values  | O(n)       |
+ * |              |                                            |                                     |            |
+ * | elements     | {@link module:MutableHashSet.has}          | Checks if a value exists in the set | O(1) avg   |
+ * | elements     | {@link module:MutableHashSet.add}          | Adds a value to the set             | O(1) avg   |
+ * | elements     | {@link module:MutableHashSet.remove}       | Removes a value from the set        | O(1) avg   |
+ * | elements     | {@link module:MutableHashSet.size}         | Gets the number of elements         | O(1)       |
+ * | elements     | {@link module:MutableHashSet.clear}        | Removes all values from the set     | O(1)       |
+ *
+ * ## Notes
+ *
+ * ### Mutability Considerations:
+ *
+ * Unlike most data structures in the Effect ecosystem, `MutableHashSet` is
+ * mutable. This means that operations like `add`, `remove`, and `clear` modify
+ * the original set rather than creating a new one. This can lead to more
+ * efficient code in some scenarios, but requires careful handling to avoid
+ * unexpected side effects.
+ *
+ * ### When to Choose `MutableHashSet` vs {@link module:HashSet}:
+ *
+ * - Use `MutableHashSet` when you need to build or modify a set incrementally and
+ *   performance is a priority
+ * - Use `HashSet` when you want immutability guarantees and functional
+ *   programming patterns
+ * - Consider using {@link module:HashSet}'s bounded mutation context (via
+ *   {@link module:HashSet.beginMutation}, {@link module:HashSet.endMutation}, and
+ *   {@link module:HashSet.mutate} methods) when you need temporary mutability
+ *   within an otherwise immutable context - this approach might be sufficient
+ *   for many use cases without requiring a separate `MutableHashSet`
+ * - `MutableHashSet` is often useful for local operations where the mutability is
+ *   contained and doesn't leak into the broader application
+ *
+ * @module MutableHashSet
  * @since 2.0.0
  */
 import * as Dual from "./Function.js";
@@ -33,45 +124,388 @@ const fromHashMap = keyMap => {
   return set;
 };
 /**
+ * Creates an empty mutable hash set.
+ *
+ * This function initializes and returns an empty `MutableHashSet` instance,
+ * which allows for efficient storage and manipulation of unique elements.
+ *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category constructors
+ * @example
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ *
+ * type T = unknown // replace with your type
+ *
+ * // in places where the type can't be inferred, replace with your type
+ * const set: MutableHashSet.MutableHashSet<T> = MutableHashSet.empty<T>()
+ * ```
+ *
+ * @template K - The type of the elements to be stored in the hash set. Defaults
+ *   to `never` if not specified.
+ * @returns A new mutable instance of `MutableHashSet` containing no elements
+ *   for the specified type `K`.
+ * @see Other `MutableHashSet` constructors are {@link module:MutableHashSet.make} {@link module:MutableHashSet.fromIterable}
  */
 export const empty = () => fromHashMap(MutableHashMap.empty());
 /**
  * Creates a new `MutableHashSet` from an iterable collection of values.
+ * Duplicate values are omitted.
+ *
+ * Time complexity: **`O(n)`** where n is the number of elements in the iterable
+ *
+ * Creating a `MutableHashSet` from an {@link Array}
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ *
+ * const array: Iterable<number> = [1, 2, 3, 4, 5, 1, 2, 3] // Array<T> is also Iterable<T>
+ * const mutableHashSet: MutableHashSet.MutableHashSet<number> =
+ *   MutableHashSet.fromIterable(array)
+ *
+ * console.log(
+ *   // MutableHashSet.MutableHashSet<T> is also an Iterable<T>
+ *   Array.from(mutableHashSet)
+ * ) // Output: [1, 2, 3, 4, 5]
+ * ```
+ *
+ * Creating a `MutableHashSet` from a {@link Set}
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     // Set<string> is an Iterable<string>
+ *     new Set(["apple", "banana", "orange", "apple"]),
+ *     // constructs MutableHashSet from an Iterable Set
+ *     MutableHashSet.fromIterable,
+ *     // since MutableHashSet it is itself an Iterable, we can pass it to other functions expecting an Iterable
+ *     Array.from
+ *   )
+ * ) // Output: ["apple", "banana", "orange"]
+ * ```
+ *
+ * Creating a `MutableHashSet` from a {@link Generator}
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ *
+ * // Generator functions return iterables
+ * function* fibonacci(n: number): Generator<number, void, never> {
+ *   let [a, b] = [0, 1]
+ *   for (let i = 0; i < n; i++) {
+ *     yield a
+ *     ;[a, b] = [b, a + b]
+ *   }
+ * }
+ *
+ * // Create a MutableHashSet from the first 10 Fibonacci numbers
+ * const fibonacciSet = MutableHashSet.fromIterable(fibonacci(10))
+ *
+ * console.log(Array.from(fibonacciSet))
+ * // Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
+ * ```
+ *
+ * Creating a `MutableHashSet` from another {@link module:MutableHashSet}
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     MutableHashSet.make(1, 2, 3, 4),
+ *     MutableHashSet.fromIterable,
+ *     Array.from
+ *   )
+ * ) // Output: [1, 2, 3, 4]
+ * ```
+ *
+ * Creating a `MutableHashSet` from an {@link module:HashSet}
+ *
+ * ```ts
+ * import { HashSet, MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     HashSet.make(1, 2, 3, 4), // it works also with its immutable HashSet sibling
+ *     MutableHashSet.fromIterable,
+ *     Array.from
+ *   )
+ * ) // Output: [1, 2, 3, 4]
+ * ```
  *
+ * Creating a `MutableHashSet` from other Effect's data structures like
+ * {@link Chunk}
+ *
+ * ```ts
+ * import { Chunk, MutableHashSet, pipe } from "effect"
+ *
+ * console.log(
+ *   pipe(
+ *     Chunk.make(1, 2, 3, 4), //  Chunk is also an Iterable<T>
+ *     MutableHashSet.fromIterable,
+ *     Array.from
+ *   )
+ * ) // Outputs: [1, 2, 3, 4]
+ * ```
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category constructors
+ * @template K - The type of elements to be stored in the resulting
+ *   `MutableHashSet`.
+ * @param keys - An `Iterable` collection containing the keys to be added to the
+ *   `MutableHashSet`.
+ * @returns A new `MutableHashSet` containing just the unique elements from the
+ *   provided iterable.
+ * @see Other `MutableHashSet` constructors are {@link module:MutableHashSet.empty} {@link module:MutableHashSet.make}
  */
 export const fromIterable = keys => fromHashMap(MutableHashMap.fromIterable(Array.from(keys).map(k => [k, true])));
 /**
+ * Construct a new `MutableHashSet` from a variable number of values.
+ *
+ * Time complexity: **`O(n)`** where n is the number of elements
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category constructors
+ * @example
+ *
+ * ```ts
+ * import { Equal, Hash, MutableHashSet } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * class Character implements Equal.Equal {
+ *   readonly name: string
+ *   readonly trait: string
+ *
+ *   constructor(name: string, trait: string) {
+ *     this.name = name
+ *     this.trait = trait
+ *   }
+ *
+ *   // Define equality based on name, and trait
+ *   [Equal.symbol](that: Equal.Equal): boolean {
+ *     if (that instanceof Character) {
+ *       return (
+ *         Equal.equals(this.name, that.name) &&
+ *         Equal.equals(this.trait, that.trait)
+ *       )
+ *     }
+ *     return false
+ *   }
+ *
+ *   // Generate a hash code based on the sum of the character's name and trait
+ *   [Hash.symbol](): number {
+ *     return Hash.hash(this.name + this.trait)
+ *   }
+ *
+ *   static readonly of = (name: string, trait: string): Character => {
+ *     return new Character(name, trait)
+ *   }
+ * }
+ *
+ * const mutableCharacterHashSet = MutableHashSet.make(
+ *   Character.of("Alice", "Curious"),
+ *   Character.of("Alice", "Curious"),
+ *   Character.of("White Rabbit", "Always late"),
+ *   Character.of("Mad Hatter", "Tea enthusiast")
+ * )
+ *
+ * assert.equal(
+ *   MutableHashSet.has(
+ *     mutableCharacterHashSet,
+ *     Character.of("Alice", "Curious")
+ *   ),
+ *   true
+ * )
+ * assert.equal(
+ *   MutableHashSet.has(
+ *     mutableCharacterHashSet,
+ *     Character.of("Fluffy", "Kind")
+ *   ),
+ *   false
+ * )
+ * ```
+ *
+ * @see Other `MutableHashSet` constructors are {@link module:MutableHashSet.fromIterable} {@link module:MutableHashSet.empty}
  */
 export const make = (...keys) => fromIterable(keys);
 /**
+ * **Checks** whether the `MutableHashSet` contains the given element, and
+ * **adds** it if not.
+ *
+ * Time complexity: **`O(1)`** average
+ *
+ * **Syntax**
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ *
+ * // with data-last, a.k.a. pipeable API
+ * pipe(
+ *   MutableHashSet.empty(),
+ *   MutableHashSet.add(0),
+ *   MutableHashSet.add(0)
+ * )
+ *
+ * // or piped with the pipe function
+ * MutableHashSet.empty().pipe(MutableHashSet.add(0))
+ *
+ * // or with data-first API
+ * MutableHashSet.add(MutableHashSet.empty(), 0)
+ * ```
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category elements
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.remove} {@link module:MutableHashSet.size} {@link module:MutableHashSet.clear} {@link module:MutableHashSet.has}
  */
 export const add = /*#__PURE__*/Dual.dual(2, (self, key) => (MutableHashMap.set(self.keyMap, key, true), self));
 /**
+ * Checks if the specified value exists in the `MutableHashSet`.
+ *
+ * Time complexity: `O(1)` average
+ *
+ * **Syntax**
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.equal(
+ *   // with `data-last`, a.k.a. `pipeable` API
+ *   pipe(MutableHashSet.make(0, 1, 2), MutableHashSet.has(3)),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or piped with the pipe function
+ *   MutableHashSet.make(0, 1, 2).pipe(MutableHashSet.has(3)),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or with `data-first` API
+ *   MutableHashSet.has(MutableHashSet.make(0, 1, 2), 3),
+ *   false
+ * )
+ * ```
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category elements
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.remove} {@link module:MutableHashSet.size} {@link module:MutableHashSet.clear}
  */
 export const has = /*#__PURE__*/Dual.dual(2, (self, key) => MutableHashMap.has(self.keyMap, key));
 /**
+ * Removes a value from the `MutableHashSet`.
+ *
+ * Time complexity: **`O(1)`** average
+ *
+ * **Syntax**
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.equal(
+ *   // with `data-last`, a.k.a. `pipeable` API
+ *   pipe(
+ *     MutableHashSet.make(0, 1, 2),
+ *     MutableHashSet.remove(0),
+ *     MutableHashSet.has(0)
+ *   ),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or piped with the pipe function
+ *   MutableHashSet.make(0, 1, 2).pipe(
+ *     MutableHashSet.remove(0),
+ *     MutableHashSet.has(0)
+ *   ),
+ *   false
+ * )
+ *
+ * assert.equal(
+ *   // or with `data-first` API
+ *   MutableHashSet.remove(MutableHashSet.make(0, 1, 2), 0).pipe(
+ *     MutableHashSet.has(0)
+ *   ),
+ *   false
+ * )
+ * ```
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category elements
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.has} {@link module:MutableHashSet.size} {@link module:MutableHashSet.clear}
  */
 export const remove = /*#__PURE__*/Dual.dual(2, (self, key) => (MutableHashMap.remove(self.keyMap, key), self));
 /**
+ * Calculates the number of values in the `HashSet`.
+ *
+ * Time complexity: **`O(1)`**
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category elements
+ * @example
+ *
+ * ```ts
+ * import { MutableHashSet } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.equal(MutableHashSet.size(MutableHashSet.empty()), 0)
+ *
+ * assert.equal(
+ *   MutableHashSet.size(MutableHashSet.make(1, 2, 2, 3, 4, 3)),
+ *   4
+ * )
+ * ```
+ *
+ * @template V - The type of the elements to be stored in the `MutableHashSet`.
+ * @param self - The `MutableHashSet` instance for which the size is to be
+ *   determined.
+ * @returns The total number of elements within the `MutableHashSet`.
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.has} {@link module:MutableHashSet.remove} {@link module:MutableHashSet.clear}
  */
 export const size = self => MutableHashMap.size(self.keyMap);
 /**
+ * Removes all values from the `MutableHashSet`.
+ *
+ * This function operates by delegating the clearing action to the underlying
+ * key map associated with the given `MutableHashSet`. It ensures that the hash
+ * set becomes empty while maintaining its existence and structure.
+ *
+ * @memberof MutableHashSet
  * @since 2.0.0
  * @category elements
+ * @example
+ *
+ * ```ts
+ * import { MutableHashSet, pipe } from "effect"
+ * import assert from "node:assert/strict"
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     MutableHashSet.make(1, 2, 3, 4),
+ *     MutableHashSet.clear,
+ *     MutableHashSet.size
+ *   ),
+ *   0
+ * )
+ * ```
+ *
+ * @param self - The `MutableHashSet` to clear.
+ * @returns The same `MutableHashSet` after all elements have been removed.
+ * @see Other `MutableHashSet` elements are {@link module:MutableHashSet.add} {@link module:MutableHashSet.has} {@link module:MutableHashSet.remove} {@link module:MutableHashSet.size}
  */
 export const clear = self => (MutableHashMap.clear(self.keyMap), self);
 //# sourceMappingURL=MutableHashSet.js.map

package/dist/esm/MutableHashSet.js.map

@@ -1 +1 @@
-{"version":3,"file":"MutableHashSet.js","names":["Dual","format","NodeInspectSymbol","toJSON","MutableHashMap","pipeArguments","TypeId","Symbol","for","MutableHashSetProto","iterator","Array","from","keyMap","map","_","toString","_id","values","pipe","arguments","fromHashMap","set","Object","create","empty","fromIterable","keys","k","make","add","dual","self","key","has","remove","size","clear"],"sources":["../../src/MutableHashSet.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"MutableHashSet.js","names":["Dual","format","NodeInspectSymbol","toJSON","MutableHashMap","pipeArguments","TypeId","Symbol","for","MutableHashSetProto","iterator","Array","from","keyMap","map","_","toString","_id","values","pipe","arguments","fromHashMap","set","Object","create","empty","fromIterable","keys","k","make","add","dual","self","key","has","remove","size","clear"],"sources":["../../src/MutableHashSet.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -736,6 +736,97 @@ export * as ModuleVersion from "./ModuleVersion.js";
  */
 export * as MutableHashMap from "./MutableHashMap.js";
 /**
+ * # MutableHashSet
+ *
+ * A mutable `MutableHashSet` provides a collection of unique values with
+ * efficient lookup, insertion and removal. Unlike its immutable sibling
+ * {@link module:HashSet}, a `MutableHashSet` can be modified in-place;
+ * operations like add, remove, and clear directly modify the original set
+ * rather than creating a new one. This mutability offers benefits like improved
+ * performance in scenarios where you need to build or modify a set
+ * incrementally.
+ *
+ * ## What Problem Does It Solve?
+ *
+ * `MutableHashSet` solves the problem of maintaining an unsorted collection
+ * where each value appears exactly once, with fast operations for checking
+ * membership and adding/removing values, in contexts where mutability is
+ * preferred for performance or implementation simplicity.
+ *
+ * ## When to Use
+ *
+ * Use `MutableHashSet` when you need:
+ *
+ * - A collection with no duplicate values
+ * - Efficient membership testing (**`O(1)`** average complexity)
+ * - In-place modifications for better performance
+ * - A set that will be built or modified incrementally
+ * - Local mutability in otherwise immutable code
+ *
+ * ## Advanced Features
+ *
+ * MutableHashSet provides operations for:
+ *
+ * - Adding and removing elements with direct mutation
+ * - Checking for element existence
+ * - Clearing all elements at once
+ * - Converting to/from other collection types
+ *
+ * ## Performance Characteristics
+ *
+ * - **Lookup** operations ({@link module:MutableHashSet.has}): **`O(1)`** average
+ *   time complexity
+ * - **Insertion** operations ({@link module:MutableHashSet.add}): **`O(1)`**
+ *   average time complexity
+ * - **Removal** operations ({@link module:MutableHashSet.remove}): **`O(1)`**
+ *   average time complexity
+ * - **Iteration**: **`O(n)`** where n is the size of the set
+ *
+ * The MutableHashSet data structure implements the following traits:
+ *
+ * - {@link Iterable}: allows iterating over the values in the set
+ * - {@link Pipeable}: allows chaining operations with the pipe operator
+ * - {@link Inspectable}: allows inspecting the contents of the set
+ *
+ * ## Operations Reference
+ *
+ * | Category     | Operation                                  | Description                         | Complexity |
+ * | ------------ | ------------------------------------------ | ----------------------------------- | ---------- |
+ * | constructors | {@link module:MutableHashSet.empty}        | Creates an empty MutableHashSet     | O(1)       |
+ * | constructors | {@link module:MutableHashSet.fromIterable} | Creates a set from an iterable      | O(n)       |
+ * | constructors | {@link module:MutableHashSet.make}         | Creates a set from multiple values  | O(n)       |
+ * |              |                                            |                                     |            |
+ * | elements     | {@link module:MutableHashSet.has}          | Checks if a value exists in the set | O(1) avg   |
+ * | elements     | {@link module:MutableHashSet.add}          | Adds a value to the set             | O(1) avg   |
+ * | elements     | {@link module:MutableHashSet.remove}       | Removes a value from the set        | O(1) avg   |
+ * | elements     | {@link module:MutableHashSet.size}         | Gets the number of elements         | O(1)       |
+ * | elements     | {@link module:MutableHashSet.clear}        | Removes all values from the set     | O(1)       |
+ *
+ * ## Notes
+ *
+ * ### Mutability Considerations:
+ *
+ * Unlike most data structures in the Effect ecosystem, `MutableHashSet` is
+ * mutable. This means that operations like `add`, `remove`, and `clear` modify
+ * the original set rather than creating a new one. This can lead to more
+ * efficient code in some scenarios, but requires careful handling to avoid
+ * unexpected side effects.
+ *
+ * ### When to Choose `MutableHashSet` vs {@link module:HashSet}:
+ *
+ * - Use `MutableHashSet` when you need to build or modify a set incrementally and
+ *   performance is a priority
+ * - Use `HashSet` when you want immutability guarantees and functional
+ *   programming patterns
+ * - Consider using {@link module:HashSet}'s bounded mutation context (via
+ *   {@link module:HashSet.beginMutation}, {@link module:HashSet.endMutation}, and
+ *   {@link module:HashSet.mutate} methods) when you need temporary mutability
+ *   within an otherwise immutable context - this approach might be sufficient
+ *   for many use cases without requiring a separate `MutableHashSet`
+ * - `MutableHashSet` is often useful for local operations where the mutability is
+ *   contained and doesn't leak into the broader application
+ *
+ * @module MutableHashSet
  * @since 2.0.0
  */
 export * as MutableHashSet from "./MutableHashSet.js";

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["absurd","flow","hole","identity","pipe","unsafeCoerce","Arbitrary","Array","BigDecimal","BigInt","Boolean","Brand","Cache","Cause","Channel","ChildExecutorDecision","Chunk","Clock","Config","ConfigError","ConfigProvider","ConfigProviderPathPatch","Console","Context","Cron","Data","DateTime","DefaultServices","Deferred","Differ","Duration","Effect","Effectable","Either","Encoding","Equal","Equivalence","ExecutionStrategy","Exit","FastCheck","Fiber","FiberHandle","FiberId","FiberMap","FiberRef","FiberRefs","FiberRefsPatch","FiberSet","FiberStatus","Function","GlobalValue","GroupBy","HKT","Hash","HashMap","HashSet","Inspectable","Iterable","JSONSchema","KeyedPool","Layer","LayerMap","List","LogLevel","LogSpan","Logger","Mailbox","ManagedRuntime","Match","MergeDecision","MergeState","MergeStrategy","Metric","MetricBoundaries","MetricHook","MetricKey","MetricKeyType","MetricLabel","MetricPair","MetricPolling","MetricRegistry","MetricState","Micro","ModuleVersion","MutableHashMap","MutableHashSet","MutableList","MutableQueue","MutableRef","NonEmptyIterable","Number","Option","Order","Ordering","ParseResult","Pipeable","Pool","Predicate","Pretty","PrimaryKey","PubSub","Queue","Random","RateLimiter","RcMap","RcRef","Readable","Record","RedBlackTree","Redacted","Ref","RegExp","Reloadable","Request","RequestBlock","RequestResolver","Resource","Runtime","RuntimeFlags","RuntimeFlagsPatch","STM","Schedule","ScheduleDecision","ScheduleInterval","ScheduleIntervals","Scheduler","Schema","SchemaAST","Scope","ScopedCache","ScopedRef","Secret","SingleProducerAsyncInput","Sink","SortedMap","SortedSet","Stream","StreamEmit","StreamHaltStrategy","Streamable","String","Struct","Subscribable","SubscriptionRef","Supervisor","Symbol","SynchronizedRef","TArray","TDeferred","TMap","TPriorityQueue","TPubSub","TQueue","TRandom","TReentrantLock","TRef","TSemaphore","TSet","TSubscriptionRef","Take","TestAnnotation","TestAnnotationMap","TestAnnotations","TestClock","TestConfig","TestContext","TestLive","TestServices","TestSized","Tracer","Trie","Tuple","Types","Unify","UpstreamPullRequest","UpstreamPullStrategy","Utils"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"index.js","names":["absurd","flow","hole","identity","pipe","unsafeCoerce","Arbitrary","Array","BigDecimal","BigInt","Boolean","Brand","Cache","Cause","Channel","ChildExecutorDecision","Chunk","Clock","Config","ConfigError","ConfigProvider","ConfigProviderPathPatch","Console","Context","Cron","Data","DateTime","DefaultServices","Deferred","Differ","Duration","Effect","Effectable","Either","Encoding","Equal","Equivalence","ExecutionStrategy","Exit","FastCheck","Fiber","FiberHandle","FiberId","FiberMap","FiberRef","FiberRefs","FiberRefsPatch","FiberSet","FiberStatus","Function","GlobalValue","GroupBy","HKT","Hash","HashMap","HashSet","Inspectable","Iterable","JSONSchema","KeyedPool","Layer","LayerMap","List","LogLevel","LogSpan","Logger","Mailbox","ManagedRuntime","Match","MergeDecision","MergeState","MergeStrategy","Metric","MetricBoundaries","MetricHook","MetricKey","MetricKeyType","MetricLabel","MetricPair","MetricPolling","MetricRegistry","MetricState","Micro","ModuleVersion","MutableHashMap","MutableHashSet","MutableList","MutableQueue","MutableRef","NonEmptyIterable","Number","Option","Order","Ordering","ParseResult","Pipeable","Pool","Predicate","Pretty","PrimaryKey","PubSub","Queue","Random","RateLimiter","RcMap","RcRef","Readable","Record","RedBlackTree","Redacted","Ref","RegExp","Reloadable","Request","RequestBlock","RequestResolver","Resource","Runtime","RuntimeFlags","RuntimeFlagsPatch","STM","Schedule","ScheduleDecision","ScheduleInterval","ScheduleIntervals","Scheduler","Schema","SchemaAST","Scope","ScopedCache","ScopedRef","Secret","SingleProducerAsyncInput","Sink","SortedMap","SortedSet","Stream","StreamEmit","StreamHaltStrategy","Streamable","String","Struct","Subscribable","SubscriptionRef","Supervisor","Symbol","SynchronizedRef","TArray","TDeferred","TMap","TPriorityQueue","TPubSub","TQueue","TRandom","TReentrantLock","TRef","TSemaphore","TSet","TSubscriptionRef","Take","TestAnnotation","TestAnnotationMap","TestAnnotations","TestClock","TestConfig","TestContext","TestLive","TestServices","TestSized","Tracer","Trie","Tuple","Types","Unify","UpstreamPullRequest","UpstreamPullStrategy","Utils"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/internal/metric/hook.js

@@ -197,7 +197,7 @@ export const summary = key => {
       if (item != null) {
         const [t, v] = item;
         const age = Duration.millis(now - t);
-        if (Duration.greaterThanOrEqualTo(age, Duration.zero) && age <= maxAge) {
+        if (Duration.greaterThanOrEqualTo(age, Duration.zero) && Duration.lessThanOrEqualTo(age, maxAge)) {
           builder.push(v);
         }
       }