@nunofyobiz/effect-extras 2.0.0 → 3.0.0

package/dist/InclusiveOr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InclusiveOr.js","names":["Array","Data","Effect","Option","Predicate","Struct","pipe","constUndefined","dual","identity","taggedEnum","LeftOnly","RightOnly","LeftAndRight","is","$is","match","$match","WithLeft","left","right","isNotNullish","WithRight","optionFromNullables","some","none","fromNullables","orElse","Error","getOrElse","matchLeft","Left","inclusiveOr","matchRight","Right","orElseLeft","orElseRight","orUndefined","undefined","leftOrElse","orElseReturn","get","leftOrUndefined","rightOrElse","rightOrUndefined","rightOption","leftOption","mapBoth","mapLeft","mapRight","mapBothEffect","map","left2","right2","all","flatMapLeft","mapLeftEffect","succeed","flatMapLeftEffect","flatMapRight","mapRightEffect","flatMapRightEffect","zip","array1","array2","f","newLength","Math","max","length","makeBy","index"],"sources":["../src/InclusiveOr.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,KAAK,EAAEC,IAAI,EAAEC,MAAM,EAAEC,MAAM,EAAEC,SAAS,EAAEC,MAAM,EAAEC,IAAI,QAAQ,QAAQ;AAC7E,SAASC,cAAc,EAAEC,IAAI,EAAEC,QAAQ,QAAQ,iBAAiB;AAiJhE,MAAMC,UAAU,gBAAGT,IAAI,CAACS,UAAU,EAAyB;AAE3D;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAMC,QAAQ,GAAGD,UAAU,CAACC,QAAQ;AAE3C;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAMC,SAAS,GAAGF,UAAU,CAACE,SAAS;AAE7C;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAMC,YAAY,GAAGH,UAAU,CAACG,YAAY;AAEnD;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,MAAMC,EAAE,GAAGJ,UAAU,CAACK,GAAG;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMC,KAAK,GAAGN,UAAU,CAACO,MAAM;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,MAAMC,QAAQ,GAAGA,CAAO;EAC7BC,IAAI;EACJC;AAAK,CAIN,KACChB,SAAS,CAACiB,YAAY,CAACD,KAAK,CAAC,GACzBP,YAAY,CAAC;EAAEM,IAAI;EAAEC;AAAK,CAAE,CAAC,GAC7BT,QAAQ,CAAC;EAAEQ;AAAI,CAAE,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,MAAMG,SAAS,GAAGA,CAAO;EAC9BH,IAAI;EACJC;AAAK,CAIN,KACChB,SAAS,CAACiB,YAAY,CAACF,IAAI,CAAC,GACxBN,YAAY,CAAC;EAAEM,IAAI;EAAEC;AAAK,CAAE,CAAC,GAC7BR,SAAS,CAAC;EAAEQ;AAAK,CAAE,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,OAAO,MAAMG,mBAAmB,GAAGA,CAAO;EACxCJ,IAAI;EACJC;AAAK,CAIN,KAAsC;EACrC,IAAIhB,SAAS,CAACiB,YAAY,CAACF,IAAI,CAAC,IAAIf,SAAS,CAACiB,YAAY,CAACD,KAAK,CAAC,EAAE;IACjE,OAAOjB,MAAM,CAACqB,IAAI,CAACX,YAAY,CAAC;MAAEM,IAAI;MAAEC;IAAK,CAAE,CAAC,CAAC;EACnD;EACA,IAAIhB,SAAS,CAACiB,YAAY,CAACF,IAAI,CAAC,EAAE;IAChC,OAAOhB,MAAM,CAACqB,IAAI,CAACb,QAAQ,CAAC;MAAEQ;IAAI,CAAE,CAAC,CAAC;EACxC;EACA,IAAIf,SAAS,CAACiB,YAAY,CAACD,KAAK,CAAC,EAAE;IACjC,OAAOjB,MAAM,CAACqB,IAAI,CAACZ,SAAS,CAAC;MAAEQ;IAAK,CAAE,CAAC,CAAC;EAC1C;EACA,OAAOjB,MAAM,CAACsB,IAAI,EAAE;AACtB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,MAAMC,aAAa,GAAGA,CAAO;EAClCP,IAAI;EACJC,KAAK;EACLO,MAAM,GAAGA,CAAA,KAAK;IACZ,MAAM,IAAIC,KAAK,CAAC,kCAAkC,CAAC;EACrD;AAAC,CAKF,KACCtB,IAAI,CAACiB,mBAAmB,CAAC;EAAEJ,IAAI;EAAEC;AAAK,CAAE,CAAC,EAAEjB,MAAM,CAAC0B,SAAS,CAACF,MAAM,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAO,MAAMG,SAAS,GACpBA,CAAU;EACRC,IAAI;EACJnB;AAAS,CAIV,KACAoB,WAA8B;AAC7B;AACAhB,KAAK,CAACgB,WAAW,EAAE;EACjBrB,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAKY,IAAI,CAACZ,IAAI,CAAC;EAClCP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAKR,SAAS,CAACQ,KAAK,CAAC;EAC1CP,YAAY,EAAEA,CAAC;IAAEM;EAAI,CAAE,KAAKY,IAAI,CAACZ,IAAI;CACtC,CAAM;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAO,MAAMc,UAAU,GACrBA,CAAU;EACRtB,QAAQ;EACRuB;AAAK,CAIN,KACAF,WAA8B;AAC7B;AACAhB,KAAK,CAACgB,WAAW,EAAE;EACjBrB,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAKR,QAAQ,CAACQ,IAAI,CAAC;EACtCP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAKc,KAAK,CAACd,KAAK,CAAC;EACtCP,YAAY,EAAEA,CAAC;IAAEO;EAAK,CAAE,KAAKc,KAAK,CAACd,KAAK;CACzC,CAAM;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAMO,MAAM,GAAGA,CAAS;EAC7BQ,UAAU;EACVC;AAAW,CAIZ,KACCpB,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAKN,YAAY,CAAC;IAAEM,IAAI;IAAEC,KAAK,EAAEgB,WAAW;EAAE,CAAE,CAAC;EACpExB,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAKP,YAAY,CAAC;IAAEM,IAAI,EAAEgB,UAAU,EAAE;IAAEf;EAAK,CAAE,CAAC;EACrEP,YAAY,EAAEA,CAAC;IAAEM,IAAI;IAAEC;EAAK,CAAE,KAAKP,YAAY,CAAC;IAAEM,IAAI;IAAEC;EAAK,CAAE;CAChE,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMiB,WAAW,gBAAGV,MAAM,CAAC;EAChCQ,UAAU,EAAEA,CAAA,KAAMG,SAAS;EAC3BF,WAAW,EAAEA,CAAA,KAAME;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,UAAU,GACjBC,YAAqB,IAClBR,WAA8B,IACnC1B,IAAI,CACF0B,WAAW,EACXL,MAAM,CAAC;EACLQ,UAAU,EAAEK,YAAY;EACxBJ,WAAW,EAAE7B;CACd,CAAC,EACFF,MAAM,CAACoC,GAAG,CAAC,MAAM,CAAC,CACnB;AAEL;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,eAAe,gBAAGH,UAAU,CAAC,MAAMD,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMK,WAAW,GAClBH,YAAqB,IAClBR,WAA8B,IACnC1B,IAAI,CACF0B,WAAW,EACXL,MAAM,CAAC;EACLQ,UAAU,EAAE5B,cAAc;EAC1B6B,WAAW,EAAEI;CACd,CAAC,EACFnC,MAAM,CAACoC,GAAG,CAAC,OAAO,CAAC,CACpB;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMG,gBAAgB,gBAAGD,WAAW,CAAC,MAAML,SAAS,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMO,WAAW,GACtBb,WAA8B,IAE9B1B,IAAI,CACF0B,WAAW,EACXC,UAAU,CAAC;EACTtB,QAAQ,EAAEA,CAAA,KAAMR,MAAM,CAACsB,IAAI,EAAE;EAC7BS,KAAK,EAAE/B,MAAM,CAACqB;CACf,CAAC,CACH;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMsB,UAAU,GACrBd,WAA8B,IAE9B1B,IAAI,CACF0B,WAAW,EACXF,SAAS,CAAC;EACRC,IAAI,EAAE5B,MAAM,CAACqB,IAAI;EACjBZ,SAAS,EAAEA,CAAA,KAAMT,MAAM,CAACsB,IAAI;CAC7B,CAAC,CACH;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMsB,OAAO,GAAGA,CAAiB;EACtCC,OAAO;EACPC;AAAQ,CAIT,KACCjC,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAKR,QAAQ,CAAC;IAAEQ,IAAI,EAAE6B,OAAO,CAAC7B,IAAI;EAAC,CAAE,CAAC;EACzDP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAKR,SAAS,CAAC;IAAEQ,KAAK,EAAE6B,QAAQ,CAAC7B,KAAK;EAAC,CAAE,CAAC;EAC/DP,YAAY,EAAEA,CAAC;IAAEM,IAAI;IAAEC;EAAK,CAAE,KAC5BP,YAAY,CAAC;IAAEM,IAAI,EAAE6B,OAAO,CAAC7B,IAAI,CAAC;IAAEC,KAAK,EAAE6B,QAAQ,CAAC7B,KAAK;EAAC,CAAE;CAC/D,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAO,MAAM8B,aAAa,GAAGA,CAAiC;EAC5DF,OAAO;EACPC;AAAQ,CAIT,KAGCjC,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KACjBb,IAAI,CACF0C,OAAO,CAAC7B,IAAI,CAAC,EACbjB,MAAM,CAACiD,GAAG,CAAEC,KAAK,IAAKzC,QAAQ,CAAC;IAAEQ,IAAI,EAAEiC;EAAK,CAAE,CAAC,CAAC,CACjD;EAEHxC,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KACnBd,IAAI,CACF2C,QAAQ,CAAC7B,KAAK,CAAC,EACflB,MAAM,CAACiD,GAAG,CAAEE,MAAM,IAAKzC,SAAS,CAAC;IAAEQ,KAAK,EAAEiC;EAAM,CAAE,CAAC,CAAC,CACrD;EAEHxC,YAAY,EAAEA,CAAC;IAAEM,IAAI;IAAEC;EAAK,CAAE,KAC5Bd,IAAI,CACFJ,MAAM,CAACoD,GAAG,CAAC;IAAEnC,IAAI,EAAE6B,OAAO,CAAC7B,IAAI,CAAC;IAAEC,KAAK,EAAE6B,QAAQ,CAAC7B,KAAK;EAAC,CAAE,CAAC,EAC3DlB,MAAM,CAACiD,GAAG,CAAC,CAAC;IAAEhC,IAAI,EAAEiC,KAAK;IAAEhC,KAAK,EAAEiC;EAAM,CAAE,KACxCxC,YAAY,CAAC;IAAEM,IAAI,EAAEiC,KAAK;IAAEhC,KAAK,EAAEiC;EAAM,CAAE,CAAC,CAC7C;CAEN,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAML,OAAO,GAClBA,OAAyB,IAEzBD,OAAO,CAAC;EAAEC,OAAO;EAAEC,QAAQ,EAAExC;AAAQ,CAAE,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAM8C,WAAW,GACtBP,OAA0C,IAE1ChC,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAK6B,OAAO,CAAC7B,IAAI,CAAC;EACrCP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAKR,SAAS,CAAC;IAAEQ;EAAK,CAAE,CAAC;EAC9CP,YAAY,EAAEA,CAAC;IAAEM;EAAI,CAAE,KAAK6B,OAAO,CAAC7B,IAAI;CACzC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMqC,aAAa,GACxBR,OAAgD,IAIhDE,aAAa,CAAC;EAAEF,OAAO;EAAEC,QAAQ,EAAE/C,MAAM,CAACuD;AAAO,CAAE,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMC,iBAAiB,GAC5BV,OAAiE,IAIjEhC,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAK6B,OAAO,CAAC7B,IAAI,CAAC;EACrCP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAKlB,MAAM,CAACuD,OAAO,CAAC7C,SAAS,CAAC;IAAEQ;EAAK,CAAE,CAAC,CAAC;EAC9DP,YAAY,EAAEA,CAAC;IAAEM;EAAI,CAAE,KAAK6B,OAAO,CAAC7B,IAAI;CACzC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAM8B,QAAQ,GACnBA,QAA2B,IAE3BF,OAAO,CAAC;EAAEC,OAAO,EAAEvC,QAAQ;EAAEwC;AAAQ,CAAE,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAO,MAAMU,YAAY,GACvBV,QAA4C,IAE5CjC,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAKR,QAAQ,CAAC;IAAEQ;EAAI,CAAE,CAAC;EAC1CP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAK6B,QAAQ,CAAC7B,KAAK,CAAC;EACzCP,YAAY,EAAEA,CAAC;IAAEO;EAAK,CAAE,KAAK6B,QAAQ,CAAC7B,KAAK;CAC5C,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMwC,cAAc,GACzBX,QAAkD,IAIlDC,aAAa,CAAC;EAAEF,OAAO,EAAE9C,MAAM,CAACuD,OAAO;EAAER;AAAQ,CAAE,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMY,kBAAkB,GAC7BZ,QAAmE,IAInEjC,KAAK,CAAC;EACJL,QAAQ,EAAEA,CAAC;IAAEQ;EAAI,CAAE,KAAKjB,MAAM,CAACuD,OAAO,CAAC9C,QAAQ,CAAC;IAAEQ;EAAI,CAAE,CAAC,CAAC;EAC1DP,SAAS,EAAEA,CAAC;IAAEQ;EAAK,CAAE,KAAK6B,QAAQ,CAAC7B,KAAK,CAAC;EACzCP,YAAY,EAAEA,CAAC;IAAEO;EAAK,CAAE,KAAK6B,QAAQ,CAAC7B,KAAK;CAC5C,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,OAAO,MAAM0C,GAAG,gBAUZtD,IAAI,CACN,CAAC,EACD,CACEuD,MAAoB,EACpBC,MAAoB,EACpBC,CAAwC,KACjC;EACP,MAAMC,SAAS,GAAGC,IAAI,CAACC,GAAG,CAACL,MAAM,CAACM,MAAM,EAAEL,MAAM,CAACK,MAAM,CAAC;EAExD,IAAIH,SAAS,KAAK,CAAC,EAAE;IACnB,OAAO,EAAE;EACX;EAEA,OAAOlE,KAAK,CAACsE,MAAM,CAACJ,SAAS,EAAGK,KAAK,IAAI;IACvC,IAAIA,KAAK,GAAGR,MAAM,CAACM,MAAM,IAAIE,KAAK,GAAGP,MAAM,CAACK,MAAM,EAAE;MAClD,OAAOJ,CAAC,CAACpD,YAAY,CAAC;QAAEM,IAAI,EAAE4C,MAAM,CAACQ,KAAK,CAAC;QAAEnD,KAAK,EAAE4C,MAAM,CAACO,KAAK;MAAC,CAAE,CAAC,CAAC;IACvE;IAEA,IAAIA,KAAK,GAAGR,MAAM,CAACM,MAAM,EAAE;MACzB,OAAOJ,CAAC,CAACtD,QAAQ,CAAC;QAAEQ,IAAI,EAAE4C,MAAM,CAACQ,KAAK;MAAC,CAAE,CAAC,CAAC;IAC7C;IAEA,IAAIA,KAAK,GAAGP,MAAM,CAACK,MAAM,EAAE;MACzB,OAAOJ,CAAC,CAACrD,SAAS,CAAC;QAAEQ,KAAK,EAAE4C,MAAM,CAACO,KAAK;MAAC,CAAE,CAAC,CAAC;IAC/C;IAEA,MAAM,IAAI3C,KAAK,CAAC,SAAS2C,KAAK,yCAAyC,CAAC;EAC1E,CAAC,CAAC;AACJ,CAAC,CACF","ignoreList":[]}

package/dist/MapX.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Like `Map.prototype.get`, but when the key is absent it stores the computed
+ * fallback at that key and returns it. Mutates the input map in place.
+ *
+ * Use it for memoization-style caches where a miss should both populate the map
+ * and yield the value in one step. Throws if the resolved value is nullish (only
+ * possible when `fallbackIfNotFound` returns `null`/`undefined` for a value type
+ * that admits them — treated as a programmer error). Supports both data-first and
+ * data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { MapX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Miss: stores the fallback and returns it (data-first)
+ * const map = new Map<string, number>()
+ * assert.deepStrictEqual(MapX.getOrElseSetGet(map, "a", () => 1), 1)
+ * assert.deepStrictEqual(map.get("a"), 1)
+ *
+ * // Hit: returns the existing value, fallback is ignored (data-last)
+ * assert.deepStrictEqual(
+ *   pipe(map, MapX.getOrElseSetGet("a", () => 99)),
+ *   1
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const getOrElseSetGet: (<K, V>(key: K, fallbackIfNotFound: () => V) => (map: Map<K, V>) => V) & (<K, V>(map: Map<K, V>, key: K, fallbackIfNotFound: () => V) => V);
+//# sourceMappingURL=MapX.d.ts.map

package/dist/MapX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapX.d.ts","sourceRoot":"","sources":["../src/MapX.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,eAAe,IACzB,CAAC,EAAE,CAAC,OAAO,CAAC,sBAAsB,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,MACnE,CAAC,EAAE,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,sBAAsB,MAAM,CAAC,KAAK,CAAC,CAahE,CAAC"}

package/dist/MapX.js

@@ -0,0 +1,49 @@
+/**
+ * Generic, framework-agnostic extensions for working with `Map`.
+ *
+ * @since 0.0.0
+ */
+import { Predicate } from "effect";
+import { dual } from "effect/Function";
+/**
+ * Like `Map.prototype.get`, but when the key is absent it stores the computed
+ * fallback at that key and returns it. Mutates the input map in place.
+ *
+ * Use it for memoization-style caches where a miss should both populate the map
+ * and yield the value in one step. Throws if the resolved value is nullish (only
+ * possible when `fallbackIfNotFound` returns `null`/`undefined` for a value type
+ * that admits them — treated as a programmer error). Supports both data-first and
+ * data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { MapX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Miss: stores the fallback and returns it (data-first)
+ * const map = new Map<string, number>()
+ * assert.deepStrictEqual(MapX.getOrElseSetGet(map, "a", () => 1), 1)
+ * assert.deepStrictEqual(map.get("a"), 1)
+ *
+ * // Hit: returns the existing value, fallback is ignored (data-last)
+ * assert.deepStrictEqual(
+ *   pipe(map, MapX.getOrElseSetGet("a", () => 99)),
+ *   1
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const getOrElseSetGet = /*#__PURE__*/dual(3, (map, key, fallbackIfNotFound) => {
+  if (!map.has(key)) {
+    map.set(key, fallbackIfNotFound());
+    return fallbackIfNotFound();
+  }
+  const existingValue = map.get(key);
+  if (Predicate.isNullish(existingValue)) {
+    throw new Error(`Value is nullable: ${String(key)}`);
+  }
+  return existingValue;
+});
+//# sourceMappingURL=MapX.js.map

package/dist/MapX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapX.js","names":["Predicate","dual","getOrElseSetGet","map","key","fallbackIfNotFound","has","set","existingValue","get","isNullish","Error","String"],"sources":["../src/MapX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,SAAS,QAAQ,QAAQ;AAClC,SAASC,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMC,eAAe,gBAAGD,IAAI,CAGjC,CAAC,EAAE,CAAOE,GAAc,EAAEC,GAAM,EAAEC,kBAA2B,KAAO;EACpE,IAAI,CAACF,GAAG,CAACG,GAAG,CAACF,GAAG,CAAC,EAAE;IACjBD,GAAG,CAACI,GAAG,CAACH,GAAG,EAAEC,kBAAkB,EAAE,CAAC;IAClC,OAAOA,kBAAkB,EAAE;EAC7B;EAEA,MAAMG,aAAa,GAAGL,GAAG,CAACM,GAAG,CAACL,GAAG,CAAC;EAClC,IAAIJ,SAAS,CAACU,SAAS,CAACF,aAAa,CAAC,EAAE;IACtC,MAAM,IAAIG,KAAK,CAAC,sBAAsBC,MAAM,CAACR,GAAG,CAAC,EAAE,CAAC;EACtD;EAEA,OAAOI,aAAa;AACtB,CAAC,CAAC","ignoreList":[]}

package/dist/NonNullableX.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Helpers for working with non-nullable values.
+ *
+ * @since 0.0.0
+ */
+import { Order } from "effect";
+/**
+ * Returns `value` narrowed to `NonNullable<A>`, throwing an `Error` if it is
+ * `null` or `undefined`.
+ *
+ * Use it at trusted boundaries where a value is known to be present but typed as
+ * nullable, turning a silent `undefined` into a loud failure. An optional
+ * `variableName` is woven into the thrown message to aid debugging. This is the
+ * function re-exported as `nn` from the module barrel, a terse shorthand handy
+ * inside string interpolations.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(NonNullableX.fromNullableOrThrow("value"), "value")
+ *
+ * assert.throws(
+ *   () => NonNullableX.fromNullableOrThrow(null, "varName"),
+ *   /Value is nullable: null \(variable name: varName\)/
+ * )
+ * ```
+ *
+ * @category unsafe
+ * @since 0.0.0
+ */
+export declare const fromNullableOrThrow: <A>(value: A, variableName?: string) => NonNullable<A>;
+/**
+ * Branches on whether `value` is nullish, passing the value narrowed to
+ * `NonNullable<A>` to the `whenNotNullable` handler.
+ *
+ * A nullable-aware sibling of `Match.value`: it folds a present-or-absent value
+ * into a single `B` without an `if`/`else` or a manual `!= null` check. Note that
+ * falsy-but-present values (`""`, `0`, `false`) take the `whenNotNullable`
+ * branch — only `null` and `undefined` are treated as absent. Supports both
+ * data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — present value flows through narrowed
+ * assert.deepStrictEqual(
+ *   NonNullableX.match("value", {
+ *     whenNullable: () => "nullable",
+ *     whenNotNullable: (value) => value
+ *   }),
+ *   "value"
+ * )
+ *
+ * // Data-last — null takes the whenNullable branch
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     null,
+ *     NonNullableX.match({
+ *       whenNullable: () => "nullable",
+ *       whenNotNullable: (value) => value
+ *     })
+ *   ),
+ *   "nullable"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export declare const match: (<A, B>(handlers: {
+    whenNullable: () => B;
+    whenNotNullable: (value: NonNullable<A>) => B;
+}) => (value: A) => B) & (<A, B>(value: A, handlers: {
+    whenNullable: () => B;
+    whenNotNullable: (value: NonNullable<A>) => B;
+}) => B);
+/**
+ * Applies `map` to `a` only when it is non-nullish, passing nullish inputs
+ * through unchanged.
+ *
+ * This is the nullable-preserving map: a present value is transformed to `B`,
+ * while `null` stays `null` and `undefined` stays `undefined`, so nullability is
+ * carried through the transformation. Supports both data-first and data-last
+ * (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — present value is transformed
+ * assert.deepStrictEqual(NonNullableX.map(1, (v: number) => v + 1), 2)
+ *
+ * // Data-last — nullish passes through unchanged
+ * const value: number | null = null
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     value,
+ *     NonNullableX.map<number | null, number>((v) => v + 1)
+ *   ),
+ *   null
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export declare const map: (<A, B>(map: (a: NonNullable<A>) => B) => (a: A) => B | (null & A) | (undefined & A)) & (<A, B>(a: A, map: (a: NonNullable<A>) => B) => B | (null & A) | (undefined & A));
+/**
+ * Lifts a total function `(a: A) => B` into one that tolerates nullish input,
+ * applying it to present values and passing `null`/`undefined` through unchanged.
+ *
+ * Where `map` operates on a value, `lift` transforms the function itself,
+ * yielding a reusable `(a: A | null | undefined) => B | null | undefined` you can
+ * drop into a `pipe`. Use it to adapt a plain transform to a nullable pipeline
+ * without wrapping each call site.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { Number, pipe } from "effect"
+ *
+ * const addOne = NonNullableX.lift(Number.sum(1))
+ *
+ * assert.deepStrictEqual(pipe(1, addOne), 2)
+ * assert.deepStrictEqual(pipe(null, addOne), null)
+ * assert.deepStrictEqual(pipe(undefined, addOne), undefined)
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export declare const lift: <A, B>(map: (a: A) => B) => (a: A | null | undefined) => B | null | undefined;
+/**
+ * Extends an `Order.Order<A>` to an `Order.Order<A | null>`, deciding where
+ * `null` sorts relative to present values via the `behavior` argument.
+ *
+ * Pass `"value-null"` to push `null`s to the end and `"null-value"` to pull them
+ * to the front; two present values fall back to the wrapped order. Use it to sort
+ * collections that mix real values with gaps without a bespoke comparator.
+ * Supports both data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { Array, Order, pipe } from "effect"
+ *
+ * // "value-null" — nulls sorted last
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     [null, 1, 3, null, 2],
+ *     Array.sort(NonNullableX.nullableOrder(Order.Number, "value-null"))
+ *   ),
+ *   [1, 2, 3, null, null]
+ * )
+ *
+ * // "null-value" — nulls sorted first (data-last)
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     [null, 1, 3, null, 2],
+ *     Array.sort(pipe(Order.Number, NonNullableX.nullableOrder("null-value")))
+ *   ),
+ *   [null, null, 1, 2, 3]
+ * )
+ * ```
+ *
+ * @category ordering
+ * @since 0.0.0
+ */
+export declare const nullableOrder: ((behavior: "value-null" | "null-value") => <A>(order: Order.Order<A>) => Order.Order<A | null>) & (<A>(order: Order.Order<A>, behavior: "value-null" | "null-value") => Order.Order<A | null>);
+//# sourceMappingURL=NonNullableX.d.ts.map

package/dist/NonNullableX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NonNullableX.d.ts","sourceRoot":"","sources":["../src/NonNullableX.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAGL,KAAK,EAGN,MAAM,QAAQ,CAAC;AAGhB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,EACnC,OAAO,CAAC,EACR,eAAe,MAAM,KACpB,WAAW,CAAC,CAAC,CAOf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,IACf,CAAC,EAAE,CAAC,YAAY;IACf,YAAY,EAAE,MAAM,CAAC,CAAC;IACtB,eAAe,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;CAC/C,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,MACpB,CAAC,EAAE,CAAC,SACI,CAAC,YACE;IACR,YAAY,EAAE,MAAM,CAAC,CAAC;IACtB,eAAe,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;CAC/C,KACE,CAAC,CAWP,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,GAAG,IACb,CAAC,EAAE,CAAC,OACE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAC1B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,MAC9C,CAAC,EAAE,CAAC,KACA,CAAC,OACC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAC1B,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,CAsBtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,GACd,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MACtB,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,CAAC,GAAG,IAAI,GAAG,SAMrC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,aAAa,cAEZ,YAAY,GAAG,YAAY,KAClC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,MACvD,CAAC,SACO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,YACX,YAAY,GAAG,YAAY,KAClC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAwC3B,CAAC"}

package/dist/NonNullableX.js

@@ -0,0 +1,217 @@
+/**
+ * Helpers for working with non-nullable values.
+ *
+ * @since 0.0.0
+ */
+import { Number as EffectNumber, Match, Predicate } from "effect";
+import { dual } from "effect/Function";
+/**
+ * Returns `value` narrowed to `NonNullable<A>`, throwing an `Error` if it is
+ * `null` or `undefined`.
+ *
+ * Use it at trusted boundaries where a value is known to be present but typed as
+ * nullable, turning a silent `undefined` into a loud failure. An optional
+ * `variableName` is woven into the thrown message to aid debugging. This is the
+ * function re-exported as `nn` from the module barrel, a terse shorthand handy
+ * inside string interpolations.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(NonNullableX.fromNullableOrThrow("value"), "value")
+ *
+ * assert.throws(
+ *   () => NonNullableX.fromNullableOrThrow(null, "varName"),
+ *   /Value is nullable: null \(variable name: varName\)/
+ * )
+ * ```
+ *
+ * @category unsafe
+ * @since 0.0.0
+ */
+export const fromNullableOrThrow = (value, variableName) => {
+  if (Predicate.isNotNullish(value)) {
+    return value;
+  }
+  throw new Error(`Value is nullable: ${String(value)}${Predicate.isNotNullish(variableName) ? ` (variable name: ${variableName})` : ""}`);
+};
+/**
+ * Branches on whether `value` is nullish, passing the value narrowed to
+ * `NonNullable<A>` to the `whenNotNullable` handler.
+ *
+ * A nullable-aware sibling of `Match.value`: it folds a present-or-absent value
+ * into a single `B` without an `if`/`else` or a manual `!= null` check. Note that
+ * falsy-but-present values (`""`, `0`, `false`) take the `whenNotNullable`
+ * branch — only `null` and `undefined` are treated as absent. Supports both
+ * data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — present value flows through narrowed
+ * assert.deepStrictEqual(
+ *   NonNullableX.match("value", {
+ *     whenNullable: () => "nullable",
+ *     whenNotNullable: (value) => value
+ *   }),
+ *   "value"
+ * )
+ *
+ * // Data-last — null takes the whenNullable branch
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     null,
+ *     NonNullableX.match({
+ *       whenNullable: () => "nullable",
+ *       whenNotNullable: (value) => value
+ *     })
+ *   ),
+ *   "nullable"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export const match = /*#__PURE__*/dual(2, (value, {
+  whenNullable,
+  whenNotNullable
+}) => Predicate.isNotNullish(value) ? whenNotNullable(value) : whenNullable());
+/**
+ * Applies `map` to `a` only when it is non-nullish, passing nullish inputs
+ * through unchanged.
+ *
+ * This is the nullable-preserving map: a present value is transformed to `B`,
+ * while `null` stays `null` and `undefined` stays `undefined`, so nullability is
+ * carried through the transformation. Supports both data-first and data-last
+ * (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — present value is transformed
+ * assert.deepStrictEqual(NonNullableX.map(1, (v: number) => v + 1), 2)
+ *
+ * // Data-last — nullish passes through unchanged
+ * const value: number | null = null
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     value,
+ *     NonNullableX.map<number | null, number>((v) => v + 1)
+ *   ),
+ *   null
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const map = /*#__PURE__*/dual(2, (a, map) => {
+  if (Predicate.isNotNullish(a)) {
+    return map(a);
+  }
+  // Every value is either nullish or not, so once the check above has failed
+  // `isNullish(a)` is always true — its false branch (and the defensive throw
+  // below) is unreachable.
+  /* v8 ignore next */
+  if (Predicate.isNullish(a)) {
+    return a;
+  }
+  /* v8 ignore next */
+  throw new Error(`Value is neither nullable nor non-nullable: ${String(a)}`);
+});
+/**
+ * Lifts a total function `(a: A) => B` into one that tolerates nullish input,
+ * applying it to present values and passing `null`/`undefined` through unchanged.
+ *
+ * Where `map` operates on a value, `lift` transforms the function itself,
+ * yielding a reusable `(a: A | null | undefined) => B | null | undefined` you can
+ * drop into a `pipe`. Use it to adapt a plain transform to a nullable pipeline
+ * without wrapping each call site.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { Number, pipe } from "effect"
+ *
+ * const addOne = NonNullableX.lift(Number.sum(1))
+ *
+ * assert.deepStrictEqual(pipe(1, addOne), 2)
+ * assert.deepStrictEqual(pipe(null, addOne), null)
+ * assert.deepStrictEqual(pipe(undefined, addOne), undefined)
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const lift = map => a => {
+  if (Predicate.isNullish(a)) {
+    return a;
+  }
+  return map(a);
+};
+/**
+ * Extends an `Order.Order<A>` to an `Order.Order<A | null>`, deciding where
+ * `null` sorts relative to present values via the `behavior` argument.
+ *
+ * Pass `"value-null"` to push `null`s to the end and `"null-value"` to pull them
+ * to the front; two present values fall back to the wrapped order. Use it to sort
+ * collections that mix real values with gaps without a bespoke comparator.
+ * Supports both data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { NonNullableX } from "@nunofyobiz/effect-extras"
+ * import { Array, Order, pipe } from "effect"
+ *
+ * // "value-null" — nulls sorted last
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     [null, 1, 3, null, 2],
+ *     Array.sort(NonNullableX.nullableOrder(Order.Number, "value-null"))
+ *   ),
+ *   [1, 2, 3, null, null]
+ * )
+ *
+ * // "null-value" — nulls sorted first (data-last)
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     [null, 1, 3, null, 2],
+ *     Array.sort(pipe(Order.Number, NonNullableX.nullableOrder("null-value")))
+ *   ),
+ *   [null, null, 1, 2, 3]
+ * )
+ * ```
+ *
+ * @category ordering
+ * @since 0.0.0
+ */
+export const nullableOrder = /*#__PURE__*/dual(2, (order, behavior) => {
+  // Prepare to sort them based on their nullability
+  const {
+    nullableSortCategory,
+    valueSortCategory
+  } = Match.value(behavior).pipe(Match.when("value-null", () => ({
+    nullableSortCategory: 1,
+    valueSortCategory: 0
+  })), Match.when("null-value", () => ({
+    nullableSortCategory: 0,
+    valueSortCategory: 1
+  })), Match.exhaustive);
+  return (a, b) => {
+    // Right off the bat, if they are both defined just return the regular ordering
+    if (Predicate.isNotNullish(a) && Predicate.isNotNullish(b)) {
+      return order(a, b);
+    }
+    // Otherwise figure out which category each value is
+    const aCategory = Predicate.isNotNullish(a) ? valueSortCategory : nullableSortCategory;
+    const bCategory = Predicate.isNotNullish(b) ? valueSortCategory : nullableSortCategory;
+    return EffectNumber.sign(aCategory - bCategory);
+  };
+});
+//# sourceMappingURL=NonNullableX.js.map

package/dist/NonNullableX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NonNullableX.js","names":["Number","EffectNumber","Match","Predicate","dual","fromNullableOrThrow","value","variableName","isNotNullish","Error","String","match","whenNullable","whenNotNullable","map","a","isNullish","lift","nullableOrder","order","behavior","nullableSortCategory","valueSortCategory","pipe","when","exhaustive","b","aCategory","bCategory","sign"],"sources":["../src/NonNullableX.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}