@nunofyobiz/effect-extras 2.0.0 → 2.1.0

package/README.md

@@ -2,8 +2,11 @@
 
 [![npm version](https://img.shields.io/npm/v/@nunofyobiz/effect-extras)](https://www.npmjs.com/package/@nunofyobiz/effect-extras)
 [![CI](https://github.com/nunofyobiz/effect-extras/actions/workflows/ci.yml/badge.svg)](https://github.com/nunofyobiz/effect-extras/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-API%20reference-blue)](https://nunofyobiz.github.io/effect-extras/)
 [![License](https://img.shields.io/npm/l/@nunofyobiz/effect-extras)](./LICENSE)
 
+📖 **[API reference & docs →](https://nunofyobiz.github.io/effect-extras/)**
+
 Generic, framework-agnostic extensions of the [Effect](https://effect.website)
 standard library. These are the `*X` utility modules — `ArrayX`, `OptionX`,
 `RecordX`, `StructX`, and friends — that extend Effect's own modules with small,
@@ -35,6 +38,33 @@ pnpm add @nunofyobiz/effect-extras
 compatible version of `effect`. This package extends Effect; it does not bundle
 it.
 
+## Tree-shaking
+
+The package is **side-effect free** (`"sideEffects": false`) and is built — the
+same way [Effect](https://effect.website) is — with `tsc` (one ESM file per
+module, no bundling) plus Babel's
+[`annotate-pure-calls`](https://github.com/Andarist/babel-plugin-annotate-pure-calls)
+pass, which stamps every helper `/*#__PURE__*/`. A bundler therefore keeps only
+what you actually use. Three import styles, finest-grained first:
+
+```ts
+// Subpath, named — only this function (and its real deps) reach your bundle.
+import { compactNullable } from "@nunofyobiz/effect-extras/ArrayX";
+
+// Subpath, namespace — `ArrayX.*`, tree-shaken per function (Effect-style).
+import * as ArrayX from "@nunofyobiz/effect-extras/ArrayX";
+
+// Root barrel — convenient; unused *modules* are shaken away, but a module you
+// touch is kept whole (per-module granularity).
+import { ArrayX } from "@nunofyobiz/effect-extras";
+```
+
+Measured (minified + brotli, `effect` externalized): a single function lands at
+**~40 B**, a whole module at **~1 kB**, the entire library at **~4.4 kB** — so a
+subpath import pays for what it uses, not the library. Budgets are enforced in CI
+via [size-limit](https://github.com/ai/size-limit); packaging correctness via
+[publint](https://publint.dev).
+
 ## What belongs here
 
 This package has exactly one job: hold the generic `*X` helpers that extend
@@ -93,7 +123,9 @@ shape — not before.
 
 ## Modules
 
-Each module is exported as a namespace from the package root:
+Each module is exported as a namespace — from the package root and from a
+matching subpath (`@nunofyobiz/effect-extras/ArrayX`); see
+[Tree-shaking](#tree-shaking):
 
 | Module         | Extends / purpose                                                          |
 | -------------- | -------------------------------------------------------------------------- |
@@ -125,7 +157,9 @@ pnpm install
 pnpm tc          # typecheck (src + tests)
 pnpm lint        # ESLint (formatting included via eslint-plugin-prettier)
 pnpm test        # vitest run
-pnpm build       # emit dist/ (ESM + bundled .d.ts) via tsup
+pnpm build       # emit dist/ (one ESM file + .d.ts per module): tsc + babel
+pnpm publint     # validate packaging (exports map, types, ESM) — needs a build
+pnpm treeshake   # enforce per-function tree-shaking budgets (size-limit) — needs a build
 pnpm knip        # unused code / deps
 pnpm check-all   # all of the above, in CI order
 ```

package/dist/ArrayX.d.ts

@@ -0,0 +1,415 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Array` module.
+ *
+ * @since 0.0.0
+ */
+import { Array, Equivalence, Option, Order, Predicate } from "effect";
+import * as WarnResult from "./WarnResult.js";
+/**
+ * Returns a shallow copy of `array` between `start` (inclusive) and `end`
+ * (exclusive), as a pipeable, dual-form alias for `Array.prototype.slice`.
+ *
+ * `Array.prototype.slice` is already non-mutating (it returns a shallow copy),
+ * but it isn't pipeable. This helper makes it composable inside `pipe(...)`
+ * chains alongside the rest of the codebase's Effect-style utilities.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(ArrayX.slice([1, 2, 3, 4], 1, 3), [2, 3])
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(pipe([1, 2, 3, 4], ArrayX.slice(1, 3)), [2, 3])
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const slice: (<A>(start: number, end: number) => (array: readonly A[]) => A[]) & (<A>(array: readonly A[], start: number, end: number) => A[]);
+/**
+ * Zips two arrays into one, calling `f` with a `WarnResult` for each index so
+ * that length mismatches are handled explicitly rather than truncated.
+ *
+ * Unlike `Array.zipWith` (which stops at the shorter array), this walks to the
+ * length of the *longer* array. The first array's element fills the `warnings`
+ * side and the second array's element fills the `success` side, so at each index
+ * `f` receives a `WarnResult.WarnResult<A, B>`: `SuccessWithWarnings` when both
+ * arrays have an element, `WarningsOnly` when only the first does, and
+ * `SuccessOnly` when only the second does. Use it when the "extra" tail of either
+ * array still carries meaning.
+ *
+ * @example
+ * ```ts
+ * import { ArrayX, WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const describe = WarnResult.match({
+ *   WarningsOnly: ({ warnings }) => `warnings ${warnings}`,
+ *   SuccessOnly: ({ success }) => `success ${success}`,
+ *   SuccessWithWarnings: ({ warnings, success }) => `both ${warnings}/${success}`,
+ * })
+ *
+ * assert.deepStrictEqual(ArrayX.zipWithWarnings([1, 2, 3], [10, 20], describe), [
+ *   "both 1/10",
+ *   "both 2/20",
+ *   "warnings 3",
+ * ])
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const zipWithWarnings: (<A, B, C>(f: (ab: WarnResult.WarnResult<A, B>) => C) => (array1: readonly A[], array2: readonly B[]) => C[]) & (<A, B, C>(array1: readonly A[], array2: readonly B[], f: (ab: WarnResult.WarnResult<A, B>) => C) => C[]);
+/**
+ * Inserts or moves a unique item in an array at a specified position.
+ *
+ * **Assumption**: Items should be unique in the array based on standard equality.
+ *
+ * **Happy case**: If the item doesn't exist in the array and the destination reference item is found:
+ * The new item is inserted before the destination reference item
+ *
+ * **Item not found in array**:
+ * - If destination reference item is found: The new item is inserted before the destination reference item
+ * - If destination reference item is not found: The new item is inserted at the end of the array
+ *
+ * **Item found but duplicated**:
+ * - If destination reference item is found: All existing copies are removed, then a single copy is inserted before the destination reference item
+ * - If destination reference item is not found: All existing copies are removed, then a single copy is inserted at the end of the array
+ *
+ * @param array - The input array to modify
+ * @param config - Configuration object containing:
+ *   - `item`: The item to insert or update (must be a string or number)
+ *   - `insertToBeLeftOf`: The item to position the new/updated item before,
+ *                         or null to insert at the end
+ *
+ * @returns A new array with the item inserted or moved to the specified position
+ *
+ * @example
+ * ```ts
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // Move an existing item to sit just before "c"
+ * assert.deepStrictEqual(
+ *   ArrayX.insertUniq(["a", "b", "c", "d"], { item: "a", insertToBeLeftOf: "c" }),
+ *   ["b", "a", "c", "d"],
+ * )
+ *
+ * // Insert a brand-new item; unknown destination falls through to the end
+ * assert.deepStrictEqual(
+ *   ArrayX.insertUniq(["a", "b"], { item: "new", insertToBeLeftOf: null }),
+ *   ["a", "b", "new"],
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const insertUniq: (<A extends string | number>(config: {
+    item: A;
+    insertToBeLeftOf: A | null;
+}) => (array: readonly A[] | A[]) => A[]) & (<A extends string | number>(array: readonly A[] | A[], config: {
+    item: A;
+    insertToBeLeftOf: A | null;
+}) => A[]);
+/**
+ * Maps over `array` while threading an accumulator, iterating from right to
+ * left instead of left to right.
+ *
+ * Identical to `Array.mapAccum`, except the traversal order is reversed: `f` is
+ * called on the last element first, and the resulting array is returned in the
+ * original (left-to-right) order. Use it when each element's mapped value
+ * depends on state accumulated from the elements that follow it.
+ *
+ * @example
+ * ```ts
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // Running suffix-sum: each slot holds the sum of itself and everything after it
+ * assert.deepStrictEqual(
+ *   ArrayX.mapRightAccum([1, 2, 3], 0, (total, n) => [total + n, total + n]),
+ *   [6, [6, 5, 3]],
+ * )
+ * ```
+ *
+ * @category folding
+ * @since 0.0.0
+ */
+export declare const mapRightAccum: (<A, B, C>(initialAccumulator: C, f: (accumulator: C, a: A, index: number) => [C, B]) => (array: A[]) => [C, B[]]) & (<A, B, C>(array: A[], initialAccumulator: C, f: (accumulator: C, a: A, index: number) => [C, B]) => [C, B[]]);
+/**
+ * Returns the maximum element of `array` according to `order`, wrapped in an
+ * `Option` so that empty arrays are handled safely.
+ *
+ * Effect's `Array.max` throws on an empty array; this returns `Option.none()`
+ * instead, and `Option.some(max)` otherwise. Reach for it whenever the input
+ * array might be empty.
+ *
+ * @example
+ * ```ts
+ * import { Option, Order, pipe } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   pipe([3, 7, 2], ArrayX.maxOption(Order.Number)),
+ *   Option.some(7),
+ * )
+ * assert.deepStrictEqual(
+ *   pipe([], ArrayX.maxOption(Order.Number)),
+ *   Option.none(),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const maxOption: (<A>(order: Order.Order<A>) => (array: A[]) => Option.Option<A>) & (<A>(array: A[], order: Order.Order<A>) => Option.Option<A>);
+/**
+ * Returns the smallest element of `array` (per `order`) that matches
+ * `predicate`, narrowed to the refined type `B`, or `Option.none()` if none
+ * match.
+ *
+ * Combines a refinement filter with `Array.min`: only elements satisfying
+ * `predicate` are considered, and the minimum of those (by `order`) is
+ * returned. The refinement narrows the element type, so the resulting `Option`
+ * carries the more specific `B`.
+ *
+ * @example
+ * ```ts
+ * import { Option, Order, pipe } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * const isEven = (n: number): n is number => n % 2 === 0
+ *
+ * assert.deepStrictEqual(
+ *   pipe([3, 4, 1, 2, 5], ArrayX.takeFirstWhere(isEven, Order.Number)),
+ *   Option.some(2),
+ * )
+ * assert.deepStrictEqual(
+ *   pipe([1, 3, 5], ArrayX.takeFirstWhere(isEven, Order.Number)),
+ *   Option.none(),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const takeFirstWhere: (<A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (array: A[]) => Option.Option<B>) & (<A, B extends A>(array: A[], predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
+/**
+ * Returns the largest element of `array` (per `order`) that matches
+ * `predicate`, narrowed to the refined type `B`, or `Option.none()` if none
+ * match.
+ *
+ * The mirror of {@link takeFirstWhere}: only elements satisfying `predicate`
+ * are considered, and the maximum of those (by `order`) is returned. The
+ * refinement narrows the element type, so the resulting `Option` carries the
+ * more specific `B`.
+ *
+ * @example
+ * ```ts
+ * import { Option, Order, pipe } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * const isEven = (n: number): n is number => n % 2 === 0
+ *
+ * assert.deepStrictEqual(
+ *   pipe([3, 4, 1, 2, 5], ArrayX.takeLastWhere(isEven, Order.Number)),
+ *   Option.some(4),
+ * )
+ * assert.deepStrictEqual(
+ *   pipe([1, 3, 5], ArrayX.takeLastWhere(isEven, Order.Number)),
+ *   Option.none(),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const takeLastWhere: (<A, B extends A>(predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => (array: A[]) => Option.Option<B>) & (<A, B extends A>(array: A[], predicate: Predicate.Refinement<A, B>, order: Order.Order<B>) => Option.Option<B>);
+/**
+ * Groups `items` into a partial record keyed by the category each item maps to
+ * via `categorize`.
+ *
+ * Each item is appended to the array under its category, preserving input
+ * order. The result is `Partial<Record<C, A[]>>` because not every possible
+ * category `C` is guaranteed to appear — only categories that received at least
+ * one item are present.
+ *
+ * @example
+ * ```ts
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * const parity = (n: number) => (n % 2 === 0 ? "even" : "odd")
+ *
+ * assert.deepStrictEqual(ArrayX.categorize([1, 2, 3, 4], parity), {
+ *   odd: [1, 3],
+ *   even: [2, 4],
+ * })
+ * ```
+ *
+ * @category folding
+ * @since 0.0.0
+ */
+export declare const categorize: <A, C extends string>(items: Iterable<A>, categorize: (a: A) => C) => Partial<Record<C, A[]>>;
+/**
+ * Removes all `null` and `undefined` elements from `array`, narrowing the
+ * element type to `NonNullable<A>`.
+ *
+ * Falsy-but-present values such as `0` and `""` are kept — only nullish values
+ * are dropped. Use it to clean up an array of optionals into a dense array of
+ * known-present values.
+ *
+ * @example
+ * ```ts
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   ArrayX.compactNullable([1, null, 2, undefined, 0, ""]),
+ *   [1, 2, 0, ""],
+ * )
+ * ```
+ *
+ * @category filtering
+ * @since 0.0.0
+ */
+export declare const compactNullable: <A>(array: A[]) => NonNullable<A>[];
+/**
+ * Drops the leading elements of `array` until `predicate` first holds, keeping
+ * everything from the first match onward.
+ *
+ * The first matching element and all subsequent elements are retained
+ * regardless of whether they match — only the prefix *before* the first match
+ * is trimmed. If nothing matches, returns an empty array.
+ *
+ * @example
+ * ```ts
+ * import { Predicate } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // Trims the leading strings, then keeps everything (including the trailing "b")
+ * assert.deepStrictEqual(
+ *   ArrayX.filterHead(["a", 1, 2, "b"], Predicate.isNumber),
+ *   [1, 2, "b"],
+ * )
+ * ```
+ *
+ * @category filtering
+ * @since 0.0.0
+ */
+export declare const filterHead: (<A>(predicate: Predicate.Predicate<A>) => (array: A[]) => A[]) & (<A>(array: A[], predicate: Predicate.Predicate<A>) => A[]);
+/**
+ * Drops the trailing elements of `array` after `predicate` last holds, keeping
+ * everything up to and including the last match.
+ *
+ * The mirror of {@link filterHead}: the last matching element and all preceding
+ * elements are retained regardless of whether they match — only the suffix
+ * *after* the last match is trimmed. If nothing matches, returns an empty
+ * array.
+ *
+ * @example
+ * ```ts
+ * import { Predicate } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // Keeps the leading "a" and trims the trailing strings after the last number
+ * assert.deepStrictEqual(
+ *   ArrayX.filterTail(["a", 1, 2, "b"], Predicate.isNumber),
+ *   ["a", 1, 2],
+ * )
+ * ```
+ *
+ * @category filtering
+ * @since 0.0.0
+ */
+export declare const filterTail: (<A>(predicate: Predicate.Predicate<A>) => (array: A[]) => A[]) & (<A>(array: A[], predicate: Predicate.Predicate<A>) => A[]);
+/**
+ * Maps `f` over `array` and drops every result that is `null` or `undefined`,
+ * narrowing the element type to `NonNullable<B>`.
+ *
+ * A nullable-friendly `Array.filterMap`: where `filterMap` expects `f` to
+ * return an `Option`, this accepts a function returning `B | null` (or
+ * `undefined`) and treats nullish results as "skip this element". Falsy-but-
+ * present values such as `0` and `""` are kept.
+ *
+ * @example
+ * ```ts
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // Keep only the even numbers, mapped to their halves
+ * assert.deepStrictEqual(
+ *   ArrayX.filterMapNullable([1, 2, 3, 4], (n) => (n % 2 === 0 ? n / 2 : null)),
+ *   [1, 2],
+ * )
+ * ```
+ *
+ * @category filtering
+ * @since 0.0.0
+ */
+export declare const filterMapNullable: (<A, B>(f: (a: A) => B | null) => (array: A[]) => NonNullable<B>[]) & (<A, B>(array: A[], f: (a: A) => B | null) => NonNullable<B>[]);
+/**
+ * Finds the first element of a 2-dimensional array (row-major order) matching
+ * `predicate`, returning it alongside its row and column indices.
+ *
+ * Scans rows top-to-bottom and, within each row, left-to-right. On a match
+ * returns `Option.some([value, rowIndex, columnIndex])`; if no element matches
+ * (or the grid is empty), returns `Option.none()`.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * const grid = [
+ *   ["A", "B", "C"],
+ *   ["D", "E", "F"],
+ * ]
+ *
+ * assert.deepStrictEqual(
+ *   ArrayX.findFirstWithIndex2d(grid, (cell) => cell === "E"),
+ *   Option.some(["E", 1, 1]),
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export declare const findFirstWithIndex2d: (<A>(predicate: Predicate.Predicate<A>) => (array: A[][]) => Option.Option<[A, number, number]>) & (<A>(array: A[][], predicate: Predicate.Predicate<A>) => Option.Option<[A, number, number]>);
+/**
+ * Splits `array` into runs of consecutive elements that share the same group
+ * value, where the group is derived by `chunk` and compared with the provided
+ * `Equivalence`.
+ *
+ * Only *adjacent* elements are grouped: a new run starts every time the group
+ * value changes from the previous element. Each entry in the result carries the
+ * `group` value and the non-empty array of `values` that produced it, preserving
+ * input order. An empty input yields an empty array. Use it for run-length-style
+ * segmentation; reach for `Array.groupBy` instead when you want all elements
+ * with the same key collapsed regardless of position.
+ *
+ * @example
+ * ```ts
+ * import { Equivalence } from "effect"
+ * import { ArrayX } from "@nunofyobiz/effect-extras"
+ *
+ * // Group adjacent numbers by parity
+ * assert.deepStrictEqual(
+ *   ArrayX.chunkBy([2, 4, 1, 3, 6], (n) => n % 2 === 0, Equivalence.Boolean),
+ *   [
+ *     { group: true, values: [2, 4] },
+ *     { group: false, values: [1, 3] },
+ *     { group: true, values: [6] },
+ *   ],
+ * )
+ * ```
+ *
+ * @category folding
+ * @since 0.0.0
+ */
+export declare const chunkBy: (<A, B>(chunk: (a: A) => B, GroupEquivalence: Equivalence.Equivalence<B>) => (array: A[]) => {
+    group: B;
+    values: Array.NonEmptyArray<A>;
+}[]) & (<A, B>(array: A[], chunk: (a: A) => B, GroupEquivalence: Equivalence.Equivalence<B>) => {
+    group: B;
+    values: Array.NonEmptyArray<A>;
+}[]);
+//# sourceMappingURL=ArrayX.d.ts.map

package/dist/ArrayX.d.ts.map

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