@nunofyobiz/effect-extras 2.0.0 → 3.0.0

package/src/{ArrayX/ArrayX.ts → ArrayX.ts}

@@ -13,9 +13,8 @@ import {
   pipe,
 } from "effect";
 import { dual, identity } from "effect/Function";
-import { RecordX } from "../RecordX";
-import { WarnResult } from "../WarnResult";
-import { ResultX } from "../ResultX";
+import * as RecordX from "./RecordX.js";
+import * as ResultX from "./ResultX.js";
 
 /**
  * Returns a shallow copy of `array` between `start` (inclusive) and `end`
@@ -47,91 +46,6 @@ export const slice = dual<
   array.slice(start, end),
 );
 
-/**
- * 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 const zipWithWarnings = dual<
-  <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[]
->(
-  3,
-  <A, B, C>(
-    array1: readonly A[],
-    array2: readonly B[],
-    f: (ab: WarnResult.WarnResult<A, B>) => C,
-  ): C[] => {
-    const newLength = Math.max(array1.length, array2.length);
-
-    if (newLength === 0) {
-      return [];
-    }
-
-    return Array.makeBy(newLength, (index) => {
-      if (index < array1.length && index < array2.length) {
-        return f(
-          WarnResult.SuccessWithWarnings({
-            warnings: array1[index],
-            success: array2[index],
-          }),
-        );
-      }
-
-      if (index < array1.length) {
-        return f(
-          WarnResult.WarningsOnly({
-            warnings: array1[index],
-          }),
-        );
-      }
-
-      if (index < array2.length) {
-        return f(
-          WarnResult.SuccessOnly({
-            success: array2[index],
-          }),
-        );
-      }
-
-      throw new Error(`Index ${index} is out of bounds for array1 and array2`);
-    });
-  },
-);
-
 /**
  * Moves a unique item within an array to a new position, using a custom identification function.
  *
@@ -181,6 +95,10 @@ const moveUniqWith = dual<
 
     // Find the source item and its index
     const sourceIndex = array.findIndex((item) => identify(item) === sourceId);
+    // Unreachable via the public API: the only caller (`insertUniq`) appends the
+    // item before delegating here, so `sourceId` is always present. Kept as a
+    // defensive no-op for direct (internal) callers.
+    /* v8 ignore next 3 */
     if (sourceIndex < 0) {
       return array;
     }

package/src/{DurationX/DurationX.ts → DurationX.ts}

@@ -5,7 +5,7 @@
  */
 import { DateTime, Duration, Match, Option } from "effect";
 import { dual, pipe } from "effect/Function";
-import { BigIntX } from "../BigIntX";
+import * as BigIntX from "./BigIntX.js";
 
 // Some private constants for conversion
 const MICROS_PER_MILLI = 1000;