@nunofyobiz/effect-extras 2.0.0 → 2.1.0

package/dist/PredicateX.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Predicate` module.
+ *
+ * @since 0.0.0
+ */
+import { Predicate } from "effect";
+/**
+ * Runs a refinement against `value` and branches on the result, passing the
+ * narrowed value to the `whenTrue` handler.
+ *
+ * It pairs a `Predicate.Refinement<A, B>` with two continuations so the success
+ * branch receives `value` already narrowed to `B`, replacing an `if`/`else` that
+ * would otherwise re-check or cast. Supports both data-first and data-last
+ * (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { PredicateX } from "@nunofyobiz/effect-extras"
+ * import { Predicate, pipe } from "effect"
+ *
+ * // Data-first
+ * assert.deepStrictEqual(
+ *   PredicateX.matchRefine("hello", Predicate.isString, {
+ *     whenTrue: (value) => `String: ${value}`,
+ *     whenFalse: () => "Not a string"
+ *   }),
+ *   "String: hello"
+ * )
+ *
+ * // Data-last (pipeable)
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     42,
+ *     PredicateX.matchRefine(Predicate.isString, {
+ *       whenTrue: (value) => `String: ${value}`,
+ *       whenFalse: () => "Not a string"
+ *     })
+ *   ),
+ *   "Not a string"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export declare const matchRefine: (<A, B extends A, C>(predicate: Predicate.Refinement<A, B>, handlers: {
+    whenFalse: () => C;
+    whenTrue: (value: B) => C;
+}) => (value: A) => C) & (<A, B extends A, C>(value: A, predicate: Predicate.Refinement<A, B>, handlers: {
+    whenFalse: () => C;
+    whenTrue: (value: B) => C;
+}) => C);
+/**
+ * Refines an `unknown` value to a non-empty `string`, returning `true` only when
+ * the value is present, is a `string`, and has at least one character.
+ *
+ * This is the compound guard the repo's conventions call for: it folds
+ * `Predicate.isNotNullish`, `Predicate.isString`, and `String.isNonEmpty` into a
+ * single reusable refinement so call sites get `value is string` narrowing
+ * without restating the three checks.
+ *
+ * @example
+ * ```ts
+ * import { PredicateX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString("hello"), true)
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString(""), false)
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString(null), false)
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString(123), false)
+ * ```
+ *
+ * @category refinements
+ * @since 0.0.0
+ */
+export declare function isNonEmptyString(value: unknown): value is string;
+//# sourceMappingURL=PredicateX.d.ts.map

package/dist/PredicateX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PredicateX.d.ts","sourceRoot":"","sources":["../src/PredicateX.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAU,MAAM,QAAQ,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,WAAW,IACrB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,aACL,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,YAC3B;IACR,SAAS,EAAE,MAAM,CAAC,CAAC;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;CAC3B,KACE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,MACnB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,SACT,CAAC,aACG,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,YAC3B;IAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAA;CAAE,KACxD,CAAC,CAQP,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAMhE"}

package/dist/PredicateX.js

@@ -0,0 +1,73 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Predicate` module.
+ *
+ * @since 0.0.0
+ */
+import { Predicate, String } from "effect";
+import { dual } from "effect/Function";
+/**
+ * Runs a refinement against `value` and branches on the result, passing the
+ * narrowed value to the `whenTrue` handler.
+ *
+ * It pairs a `Predicate.Refinement<A, B>` with two continuations so the success
+ * branch receives `value` already narrowed to `B`, replacing an `if`/`else` that
+ * would otherwise re-check or cast. Supports both data-first and data-last
+ * (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { PredicateX } from "@nunofyobiz/effect-extras"
+ * import { Predicate, pipe } from "effect"
+ *
+ * // Data-first
+ * assert.deepStrictEqual(
+ *   PredicateX.matchRefine("hello", Predicate.isString, {
+ *     whenTrue: (value) => `String: ${value}`,
+ *     whenFalse: () => "Not a string"
+ *   }),
+ *   "String: hello"
+ * )
+ *
+ * // Data-last (pipeable)
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     42,
+ *     PredicateX.matchRefine(Predicate.isString, {
+ *       whenTrue: (value) => `String: ${value}`,
+ *       whenFalse: () => "Not a string"
+ *     })
+ *   ),
+ *   "Not a string"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export const matchRefine = /*#__PURE__*/dual(3, (value, predicate, handlers) => predicate(value) ? handlers.whenTrue(value) : handlers.whenFalse());
+/**
+ * Refines an `unknown` value to a non-empty `string`, returning `true` only when
+ * the value is present, is a `string`, and has at least one character.
+ *
+ * This is the compound guard the repo's conventions call for: it folds
+ * `Predicate.isNotNullish`, `Predicate.isString`, and `String.isNonEmpty` into a
+ * single reusable refinement so call sites get `value is string` narrowing
+ * without restating the three checks.
+ *
+ * @example
+ * ```ts
+ * import { PredicateX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString("hello"), true)
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString(""), false)
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString(null), false)
+ * assert.deepStrictEqual(PredicateX.isNonEmptyString(123), false)
+ * ```
+ *
+ * @category refinements
+ * @since 0.0.0
+ */
+export function isNonEmptyString(value) {
+  return Predicate.isNotNullish(value) && Predicate.isString(value) && String.isNonEmpty(value);
+}
+//# sourceMappingURL=PredicateX.js.map

package/dist/PredicateX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PredicateX.js","names":["Predicate","String","dual","matchRefine","value","predicate","handlers","whenTrue","whenFalse","isNonEmptyString","isNotNullish","isString","isNonEmpty"],"sources":["../src/PredicateX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,SAAS,EAAEC,MAAM,QAAQ,QAAQ;AAC1C,SAASC,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,OAAO,MAAMC,WAAW,gBAAGD,IAAI,CAc7B,CAAC,EACD,CACEE,KAAQ,EACRC,SAAqC,EACrCC,QAA2D,KACpDD,SAAS,CAACD,KAAK,CAAC,GAAGE,QAAQ,CAACC,QAAQ,CAACH,KAAK,CAAC,GAAGE,QAAQ,CAACE,SAAS,EAAG,CAC7E;AAED;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAM,SAAUC,gBAAgBA,CAACL,KAAc;EAC7C,OACEJ,SAAS,CAACU,YAAY,CAACN,KAAK,CAAC,IAC7BJ,SAAS,CAACW,QAAQ,CAACP,KAAK,CAAC,IACzBH,MAAM,CAACW,UAAU,CAACR,KAAK,CAAC;AAE5B","ignoreList":[]}

package/dist/PromiseX.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Helpers for working with native `Promise`s.
+ *
+ * @since 0.0.0
+ */
+/**
+ * Discards the resolved value of a `Promise`, returning a `Promise<void>` that
+ * resolves once the original settles.
+ *
+ * Useful when you await a promise only for its side effect and want the result
+ * type to reflect that nothing meaningful is produced — for example when an API
+ * expects a `Promise<void>` or when narrowing a value-bearing promise to keep
+ * call sites from accidentally depending on the resolved value. A rejection of
+ * the original promise still propagates.
+ *
+ * @example
+ * ```ts
+ * import { PromiseX } from "@nunofyobiz/effect-extras"
+ *
+ * const run = async (): Promise<void> => {
+ *   const result = await PromiseX.asVoid(Promise.resolve(42))
+ *   assert.deepStrictEqual(result, undefined)
+ * }
+ *
+ * void run()
+ * ```
+ *
+ * @category conversions
+ * @since 0.0.0
+ */
+export declare const asVoid: <T>(promise: Promise<T>) => Promise<void>;
+//# sourceMappingURL=PromiseX.d.ts.map

package/dist/PromiseX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseX.d.ts","sourceRoot":"","sources":["../src/PromiseX.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,SAAS,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,IAAI,CAC7B,CAAC"}

package/dist/PromiseX.js

@@ -0,0 +1,32 @@
+/**
+ * Helpers for working with native `Promise`s.
+ *
+ * @since 0.0.0
+ */
+/**
+ * Discards the resolved value of a `Promise`, returning a `Promise<void>` that
+ * resolves once the original settles.
+ *
+ * Useful when you await a promise only for its side effect and want the result
+ * type to reflect that nothing meaningful is produced — for example when an API
+ * expects a `Promise<void>` or when narrowing a value-bearing promise to keep
+ * call sites from accidentally depending on the resolved value. A rejection of
+ * the original promise still propagates.
+ *
+ * @example
+ * ```ts
+ * import { PromiseX } from "@nunofyobiz/effect-extras"
+ *
+ * const run = async (): Promise<void> => {
+ *   const result = await PromiseX.asVoid(Promise.resolve(42))
+ *   assert.deepStrictEqual(result, undefined)
+ * }
+ *
+ * void run()
+ * ```
+ *
+ * @category conversions
+ * @since 0.0.0
+ */
+export const asVoid = promise => promise.then(() => undefined);
+//# sourceMappingURL=PromiseX.js.map

package/dist/PromiseX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseX.js","names":["asVoid","promise","then","undefined"],"sources":["../src/PromiseX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMA,MAAM,GAAOC,OAAmB,IAC3CA,OAAO,CAACC,IAAI,CAAC,MAAMC,SAAS,CAAC","ignoreList":[]}

package/dist/RecordX.d.ts

@@ -0,0 +1,323 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Record` module.
+ *
+ * @since 0.0.0
+ */
+import { Option, Order, Predicate } from "effect";
+/**
+ * Returns `true` when `record` has at least one entry, narrowing it to a
+ * known-non-empty `Record`.
+ *
+ * The negation of `Record.isEmptyRecord`, packaged as a type guard so it reads
+ * naturally at call sites that want to branch on "this record has something in
+ * it" without a manual `!Record.isEmptyRecord(...)`.
+ *
+ * @example
+ * ```ts
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(RecordX.isNonEmptyRecord({ a: 1 }), true)
+ * assert.deepStrictEqual(RecordX.isNonEmptyRecord({}), false)
+ * ```
+ *
+ * @category guards
+ * @since 0.0.0
+ */
+export declare const isNonEmptyRecord: <K extends PropertyKey, V>(record: Record<K, V>) => record is Record<K, V>;
+/**
+ * Modifies the value at `key` in `self` with `f`, leaving the record unchanged
+ * if the key doesn't exist.
+ *
+ * v4's `Record.modify` returns `Option<Record>` — `None` when the key is
+ * absent. This helper picks the "do nothing if absent" semantics that v3's
+ * `Record.modify` had implicitly, and that most call sites assume. The modifier
+ * is never invoked when the key is missing.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   RecordX.modifyIfExists({ a: 1, b: 2 }, "b", (n) => n * 10),
+ *   { a: 1, b: 20 },
+ * )
+ *
+ * // a missing key leaves the record untouched
+ * const counts: Record<string, number> = { a: 1, b: 2 }
+ * assert.deepStrictEqual(
+ *   RecordX.modifyIfExists(counts, "missing", (n) => n + 1),
+ *   { a: 1, b: 2 },
+ * )
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(
+ *   pipe({ a: 1, b: 2 }, RecordX.modifyIfExists("a", (n) => n * 10)),
+ *   { a: 10, b: 2 },
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export declare const modifyIfExists: {
+    <K extends string, A>(key: NoInfer<K>, f: (a: A) => A): (self: Record<K, A>) => Record<K, A>;
+    <K extends string, A>(self: Record<K, A>, key: NoInfer<K>, f: (a: A) => A): Record<K, A>;
+};
+/**
+ * Returns the smallest value of `record` (per `order`) that matches
+ * `predicate`, narrowed to the refined type `B`, or `Option.none()` if none
+ * match.
+ *
+ * The `Record` counterpart of `ArrayX.takeFirstWhere`: it considers only the
+ * record's values, keeps those satisfying `predicate`, and returns the minimum
+ * of them by `order`. Keys are ignored entirely.
+ *
+ * @example
+ * ```ts
+ * import { Option, Order, pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * const isEven = (n: number): n is number => n % 2 === 0
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   RecordX.takeFirstWhere({ a: 3, b: 4, c: 2 }, isEven, Order.Number),
+ *   Option.some(2),
+ * )
+ *
+ * // data-last (pipeable); no even values yields None
+ * assert.deepStrictEqual(
+ *   pipe({ a: 1, b: 3 }, RecordX.takeFirstWhere(isEven, Order.Number)),
+ *   Option.none(),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const takeFirstWhere: (<K extends PropertyKey, A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (record: Record<K, A>) => Option.Option<B>) & (<K extends PropertyKey, A, B extends A>(record: Record<K, A>, predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
+/**
+ * Returns the largest value of `record` (per `order`) that matches `predicate`,
+ * narrowed to the refined type `B`, or `Option.none()` if none match.
+ *
+ * The mirror of {@link takeFirstWhere}: it considers only the record's values,
+ * keeps those satisfying `predicate`, and returns the maximum of them by
+ * `order`. Keys are ignored entirely.
+ *
+ * @example
+ * ```ts
+ * import { Option, Order, pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * const isEven = (n: number): n is number => n % 2 === 0
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   RecordX.takeLastWhere({ a: 3, b: 4, c: 2 }, isEven, Order.Number),
+ *   Option.some(4),
+ * )
+ *
+ * // data-last (pipeable); no even values yields None
+ * assert.deepStrictEqual(
+ *   pipe({ a: 1, b: 3 }, RecordX.takeLastWhere(isEven, Order.Number)),
+ *   Option.none(),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const takeLastWhere: (<K extends PropertyKey, A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (record: Record<K, A>) => Option.Option<B>) & (<K extends PropertyKey, A, B extends A>(record: Record<K, A>, predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
+/**
+ * Returns the largest value of `record` according to `order`, wrapped in an
+ * `Option` so empty records are handled safely.
+ *
+ * Sorts the record's values by `order` and takes the last one, yielding
+ * `Option.none()` when the record is empty and `Option.some(max)` otherwise.
+ * Keys are ignored — only values participate in the ordering.
+ *
+ * @example
+ * ```ts
+ * import { Option, Order, pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   RecordX.takeLast({ a: 3, b: 5, c: 1 }, Order.Number),
+ *   Option.some(5),
+ * )
+ *
+ * // data-last (pipeable); empty record yields None
+ * assert.deepStrictEqual(
+ *   pipe({}, RecordX.takeLast(Order.Number)),
+ *   Option.none(),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const takeLast: (<K extends PropertyKey, A>(order: Order.Order<A>) => (record: Record<K, A>) => Option.Option<A>) & (<K extends PropertyKey, A>(record: Record<K, A>, order: Order.Order<A>) => Option.Option<A>);
+/**
+ * Re-types the keys of a `Record` to a different key type `K2` without touching
+ * the runtime value.
+ *
+ * A purely type-level reinterpretation: the record is returned as-is, but the
+ * compiler now treats its keys as `K2` instead of the inferred `K1`. Use it at a
+ * boundary where you know the keys conform to a narrower branded or literal key
+ * type that TypeScript can't infer from the value alone. It performs no
+ * validation — the caller is responsible for the keys actually matching `K2`.
+ *
+ * @example
+ * ```ts
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * type UserId = string & { readonly _brand: "UserId" }
+ *
+ * const byId: Record<string, number> = { u1: 10, u2: 20 }
+ * const branded = RecordX.keysAs<UserId>()(byId)
+ *
+ * // Same runtime value, keys now seen as `UserId`
+ * assert.deepStrictEqual(branded, { u1: 10, u2: 20 })
+ * ```
+ *
+ * @category conversions
+ * @since 0.0.0
+ */
+export declare const keysAs: <K2 extends PropertyKey>() => <K1 extends PropertyKey, V>(record: Record<K1, V>) => Record<K2, V>;
+/**
+ * Returns the value at `key` in `record`, throwing an `Error` if the key is
+ * absent.
+ *
+ * The unsafe, get-or-explode counterpart to `Record.get` (which returns an
+ * `Option`). The thrown error names the missing key and lists the record's
+ * existing keys to aid debugging. Reach for {@link getOrThrowWith} when you need
+ * a custom error; prefer `Record.get` whenever absence is a real possibility.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * const record: Record<string, number> = { a: 1, b: 2 }
+ *
+ * // data-first
+ * assert.deepStrictEqual(RecordX.getOrThrow(record, "a"), 1)
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(pipe(record, RecordX.getOrThrow("b")), 2)
+ *
+ * // missing key throws
+ * assert.throws(() => RecordX.getOrThrow(record, "missing"))
+ * ```
+ *
+ * @category unsafe
+ * @since 0.0.0
+ */
+export declare const getOrThrow: (<K extends string | symbol>(key: K) => <V>(record: Record<K, V>) => V) & (<K extends string | symbol, V>(record: Record<K, V>, key: K) => V);
+/**
+ * Returns the value at `key` in `record`, throwing the result of `onNone(key)`
+ * if the key is absent.
+ *
+ * Like {@link getOrThrow}, but lets the caller supply the thrown value (an
+ * `Error`, a string, or any custom failure) computed from the missing key. Use
+ * it when the default "key not found" message isn't descriptive enough for the
+ * call site.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * const record: Record<string, number> = { a: 1 }
+ * const onNone = (key: string) => new Error(`no ${key}`)
+ *
+ * // data-first
+ * assert.deepStrictEqual(RecordX.getOrThrowWith(record, "a", onNone), 1)
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(pipe(record, RecordX.getOrThrowWith("a", onNone)), 1)
+ *
+ * // missing key throws the custom error
+ * assert.throws(() => RecordX.getOrThrowWith(record, "missing", onNone))
+ * ```
+ *
+ * @category unsafe
+ * @since 0.0.0
+ */
+export declare const getOrThrowWith: (<K extends string | symbol>(key: K, onNone: (key: K) => unknown) => <V>(record: Record<K, V>) => V) & (<K extends string | symbol, V>(record: Record<K, V>, key: K, onNone: (key: K) => unknown) => V);
+/**
+ * Inserts or updates the value at `key`, deriving the new value from the current
+ * one via `upsert`.
+ *
+ * The `upsert` function receives an `Option` of the existing value —
+ * `Option.some(value)` when the key is present, `Option.none()` when it's
+ * absent — and returns the value to store. This unifies "insert if missing" and
+ * "update if present" into a single pass, with `Option.match` as the natural way
+ * to handle both cases.
+ *
+ * @example
+ * ```ts
+ * import { Option, pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * const bump = Option.match({
+ *   onNone: () => 1,
+ *   onSome: (n: number) => n + 1,
+ * })
+ *
+ * // data-first: updates an existing entry
+ * assert.deepStrictEqual(RecordX.upsert({ a: 1 }, "a", bump), { a: 2 })
+ *
+ * // data-last (pipeable): inserts a missing entry
+ * const counts: Record<string, number> = { a: 1 }
+ * assert.deepStrictEqual(pipe(counts, RecordX.upsert("b", bump)), {
+ *   a: 1,
+ *   b: 1,
+ * })
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export declare const upsert: (<K extends string | symbol, V>(key: K, upsert: (existingValue: Option.Option<V>) => V) => (record: Record<K, V>) => Record<K, V>) & (<K extends string | symbol, V>(record: Record<K, V>, key: K, upsert: (existingValue: Option.Option<V>) => V) => Record<K, V>);
+/**
+ * Indexes an iterable of values into a `Record`, keying each value by the result
+ * of `identify`.
+ *
+ * Builds a lookup table from a collection: every value is stored under the key
+ * `identify(value)`. When two values produce the same key the later one wins, so
+ * the result holds the last value seen per key. Useful for turning a list of
+ * records into a by-id map.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { RecordX } from "@nunofyobiz/effect-extras"
+ *
+ * const items = [
+ *   { id: "a", n: 1 },
+ *   { id: "b", n: 2 },
+ *   { id: "a", n: 3 }, // wins over the earlier "a"
+ * ]
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   RecordX.collectBy(items, (item) => item.id),
+ *   { a: { id: "a", n: 3 }, b: { id: "b", n: 2 } },
+ * )
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(
+ *   pipe(items, RecordX.collectBy((item) => item.id)),
+ *   { a: { id: "a", n: 3 }, b: { id: "b", n: 2 } },
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export declare const collectBy: (<K extends string | symbol, V>(identify: (v: V) => K) => (values: Iterable<V>) => Record<K, V>) & (<K extends string | symbol, V>(values: Iterable<V>, identify: (v: V) => K) => Record<K, V>);
+//# sourceMappingURL=RecordX.d.ts.map

package/dist/RecordX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordX.d.ts","sourceRoot":"","sources":["../src/RecordX.ts"],"names":[],"mappings":"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"}