@nunofyobiz/effect-extras 2.0.0 → 3.0.0

package/dist/OptionX.js

@@ -0,0 +1,201 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Option` module.
+ *
+ * @since 0.0.0
+ */
+import { Option, Predicate, pipe } from "effect";
+import { dual } from "effect/Function";
+/**
+ * Combines two `Option`s into an `Option` of a tuple, succeeding only when both
+ * are `Some`.
+ *
+ * Returns `Some([a, b])` when both inputs are `Some`, and `None` if either is
+ * `None`. Useful when an operation needs two optional values present at once.
+ *
+ * @example
+ * ```ts
+ * import { Option, pipe } from "effect"
+ * import { OptionX } from "@nunofyobiz/effect-extras"
+ *
+ * // Both Some — succeeds with the pair
+ * assert.deepStrictEqual(
+ *   OptionX.tupleOf(Option.some(1), Option.some("a")),
+ *   Option.some([1, "a"]),
+ * )
+ *
+ * // Either None collapses to None
+ * assert.deepStrictEqual(
+ *   OptionX.tupleOf(Option.some(1), Option.none()),
+ *   Option.none(),
+ * )
+ *
+ * // Data-last (piped): the piped Option fills the first tuple slot
+ * assert.deepStrictEqual(
+ *   pipe(Option.some(1), OptionX.tupleOf(Option.some("a"))),
+ *   Option.some([1, "a"]),
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const tupleOf = /*#__PURE__*/dual(2, (a, b) => Option.flatMap(a, a => Option.map(b, b => [a, b])));
+/**
+ * Runs a side effect with the value of an `Option` when it is `Some`, doing
+ * nothing when it is `None`.
+ *
+ * A shorthand for the "if Some, do something" branch of `Option.match` where the
+ * `None` case is a no-op. The callback's return value is ignored — `ifSome`
+ * always returns `void`.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "effect"
+ * import { OptionX } from "@nunofyobiz/effect-extras"
+ *
+ * const log: Array<number> = []
+ * OptionX.ifSome(Option.some(1), (value) => log.push(value))
+ * OptionX.ifSome(Option.none<number>(), (value) => log.push(value))
+ *
+ * assert.deepStrictEqual(log, [1])
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const ifSome = /*#__PURE__*/dual(2, (self, ifSome) => {
+  Option.match(self, {
+    onSome: value => {
+      ifSome(value);
+      // Don't return anything
+    },
+    onNone: () => {
+      // Do nothing
+    }
+  });
+});
+/**
+ * Runs a side effect with the value of an `Option` when it is `Some`, then
+ * returns the `Option` unchanged.
+ *
+ * The pass-through counterpart of {@link ifSome}: it taps into a `Some` value
+ * (for logging, metrics, debugging) without breaking a `pipe` chain, since it
+ * returns the original `Option`. For `None` it is a no-op.
+ *
+ * @example
+ * ```ts
+ * import { Option, pipe } from "effect"
+ * import { OptionX } from "@nunofyobiz/effect-extras"
+ *
+ * const log: Array<number> = []
+ * const result = pipe(
+ *   Option.some(1),
+ *   OptionX.inspectSome((value) => log.push(value)),
+ *   Option.map((value) => value + 1),
+ * )
+ *
+ * assert.deepStrictEqual(result, Option.some(2))
+ * assert.deepStrictEqual(log, [1])
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const inspectSome = /*#__PURE__*/dual(2, (self, function_) => {
+  ifSome(self, function_);
+  return self;
+});
+/**
+ * Normalizes a possibly-nullish `Option` into a plain `Option`, mapping `null`
+ * and `undefined` to `None`.
+ *
+ * Handy at boundaries where an `Option` value might itself arrive as `null` or
+ * `undefined` (for example an optional field that holds an `Option`): the result
+ * is always a well-formed `Option`, never `null`/`undefined`.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "effect"
+ * import { OptionX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(OptionX.fromNullableOption(Option.some(1)), Option.some(1))
+ * assert.deepStrictEqual(OptionX.fromNullableOption(null), Option.none())
+ * assert.deepStrictEqual(OptionX.fromNullableOption(undefined), Option.none())
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const fromNullableOption = nullableOption => Predicate.isNotNullish(nullableOption) ? nullableOption : Option.none();
+/**
+ * Maps the value of an `Option` when it is `Some`, returning `null` when it is
+ * `None`.
+ *
+ * A shorthand for `pipe(self, Option.map(map), Option.getOrNull)`. The `null`
+ * fallback makes it especially convenient in JSX/React, where rendering `null`
+ * skips output — `mapSomeOrNull(value, (v) => render(v))` replaces a more verbose
+ * `Option.match` with `onNone: () => null`.
+ *
+ * @example
+ * ```ts
+ * import { Option, pipe } from "effect"
+ * import { OptionX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(OptionX.mapSomeOrNull(Option.some(1), (v) => v + 1), 2)
+ *
+ * // None maps to null
+ * assert.deepStrictEqual(
+ *   OptionX.mapSomeOrNull(Option.none<number>(), (v) => v + 1),
+ *   null,
+ * )
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(
+ *   pipe(Option.some(1), OptionX.mapSomeOrNull((v) => v + 1)),
+ *   2,
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const mapSomeOrNull = /*#__PURE__*/dual(2, (self, map) => pipe(self, Option.map(map), Option.getOrNull));
+/**
+ * Maps the value of an `Option` when it is `Some`, returning `undefined` when it
+ * is `None`.
+ *
+ * The `undefined`-returning counterpart of {@link mapSomeOrNull}: a shorthand for
+ * `pipe(self, Option.map(map), Option.getOrUndefined)`. Reach for it when the
+ * consuming API expects `undefined` rather than `null` for "absent" (for example
+ * an optional prop or a value spread into an object).
+ *
+ * @example
+ * ```ts
+ * import { Option, pipe } from "effect"
+ * import { OptionX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   OptionX.mapSomeOrUndefined(Option.some(1), (v) => v + 1),
+ *   2,
+ * )
+ *
+ * // None maps to undefined
+ * assert.deepStrictEqual(
+ *   OptionX.mapSomeOrUndefined(Option.none<number>(), (v) => v + 1),
+ *   undefined,
+ * )
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(
+ *   pipe(Option.some(1), OptionX.mapSomeOrUndefined((v) => v + 1)),
+ *   2,
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const mapSomeOrUndefined = /*#__PURE__*/dual(2, (self, map) => pipe(self, Option.map(map), Option.getOrUndefined));
+//# sourceMappingURL=OptionX.js.map

package/dist/OptionX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionX.js","names":["Option","Predicate","pipe","dual","tupleOf","a","b","flatMap","map","ifSome","self","match","onSome","value","onNone","inspectSome","function_","fromNullableOption","nullableOption","isNotNullish","none","mapSomeOrNull","getOrNull","mapSomeOrUndefined","getOrUndefined"],"sources":["../src/OptionX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,MAAM,EAAEC,SAAS,EAAEC,IAAI,QAAQ,QAAQ;AAChD,SAASC,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,OAAO,MAAMC,OAAO,gBAAGD,IAAI,CAIzB,CAAC,EACD,CAAOE,CAAmB,EAAEC,CAAmB,KAC7CN,MAAM,CAACO,OAAO,CAACF,CAAC,EAAGA,CAAC,IAAKL,MAAM,CAACQ,GAAG,CAACF,CAAC,EAAGA,CAAC,IAAK,CAACD,CAAC,EAAEC,CAAC,CAAC,CAAC,CAAC,CACzD;AAED;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAMG,MAAM,gBAAGN,IAAI,CAGxB,CAAC,EAAE,CAAIO,IAAsB,EAAED,MAA0B,KAAU;EACnET,MAAM,CAACW,KAAK,CAACD,IAAI,EAAE;IACjBE,MAAM,EAAGC,KAAK,IAAI;MAChBJ,MAAM,CAACI,KAAK,CAAC;MACb;IACF,CAAC;IACDC,MAAM,EAAEA,CAAA,KAAK;MACX;IAAA;GAEH,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,MAAMC,WAAW,gBAAGZ,IAAI,CAM7B,CAAC,EACD,CACEO,IAAsB,EACtBM,SAA6B,KACT;EACpBP,MAAM,CAACC,IAAI,EAAEM,SAAS,CAAC;EACvB,OAAON,IAAI;AACb,CAAC,CACF;AAED;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMO,kBAAkB,GAC7BC,cAAmD,IAEnDjB,SAAS,CAACkB,YAAY,CAACD,cAAc,CAAC,GAAGA,cAAc,GAAGlB,MAAM,CAACoB,IAAI,EAAE;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,OAAO,MAAMC,aAAa,gBAAGlB,IAAI,CAG/B,CAAC,EAAE,CAAOO,IAAsB,EAAEF,GAAgB,KAClDN,IAAI,CAACQ,IAAI,EAAEV,MAAM,CAACQ,GAAG,CAACA,GAAG,CAAC,EAAER,MAAM,CAACsB,SAAS,CAAC,CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,OAAO,MAAMC,kBAAkB,gBAAGpB,IAAI,CAGpC,CAAC,EAAE,CAAOO,IAAsB,EAAEF,GAAgB,KAClDN,IAAI,CAACQ,IAAI,EAAEV,MAAM,CAACQ,GAAG,CAACA,GAAG,CAAC,EAAER,MAAM,CAACwB,cAAc,CAAC,CACnD","ignoreList":[]}

package/dist/OrderX.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Order` module.
+ *
+ * @since 0.0.0
+ */
+import { Order } from "effect";
+/**
+ * Builds an `Order.Order` for an enum-like set of values from an explicit rank
+ * table, sorting each value by its assigned numeric rank.
+ *
+ * Use it when a union of string (or other `PropertyKey`) literals has a natural
+ * priority that isn't its alphabetical order — pass a record mapping every
+ * member to a rank and the resulting order sorts ascending by that rank.
+ *
+ * @example
+ * ```ts
+ * import { OrderX } from "@nunofyobiz/effect-extras"
+ * import { Array } from "effect"
+ *
+ * const byAge = OrderX.rankedEnum({ child: 0, parent: 1, grandparent: 2 })
+ *
+ * assert.deepStrictEqual(
+ *   Array.sort(["parent", "grandparent", "child"], byAge),
+ *   ["child", "parent", "grandparent"]
+ * )
+ * ```
+ *
+ * @category ordering
+ * @since 0.0.0
+ */
+export declare const rankedEnum: <const A extends PropertyKey>(ranks: Record<A, number>) => Order.Order<A>;
+//# sourceMappingURL=OrderX.d.ts.map

package/dist/OrderX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderX.d.ts","sourceRoot":"","sources":["../src/OrderX.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAA0B,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,GACpB,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAExB,CAAC"}

package/dist/OrderX.js

@@ -0,0 +1,32 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Order` module.
+ *
+ * @since 0.0.0
+ */
+import { Number as EffectNumber } from "effect";
+/**
+ * Builds an `Order.Order` for an enum-like set of values from an explicit rank
+ * table, sorting each value by its assigned numeric rank.
+ *
+ * Use it when a union of string (or other `PropertyKey`) literals has a natural
+ * priority that isn't its alphabetical order — pass a record mapping every
+ * member to a rank and the resulting order sorts ascending by that rank.
+ *
+ * @example
+ * ```ts
+ * import { OrderX } from "@nunofyobiz/effect-extras"
+ * import { Array } from "effect"
+ *
+ * const byAge = OrderX.rankedEnum({ child: 0, parent: 1, grandparent: 2 })
+ *
+ * assert.deepStrictEqual(
+ *   Array.sort(["parent", "grandparent", "child"], byAge),
+ *   ["child", "parent", "grandparent"]
+ * )
+ * ```
+ *
+ * @category ordering
+ * @since 0.0.0
+ */
+export const rankedEnum = ranks => (self, that) => EffectNumber.sign(ranks[self] - ranks[that]);
+//# sourceMappingURL=OrderX.js.map

package/dist/OrderX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderX.js","names":["Number","EffectNumber","rankedEnum","ranks","self","that","sign"],"sources":["../src/OrderX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,MAAM,IAAIC,YAAY,QAAe,QAAQ;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMC,UAAU,GACSC,KAAwB,IACtD,CAACC,IAAI,EAAEC,IAAI,KACTJ,YAAY,CAACK,IAAI,CAACH,KAAK,CAACC,IAAI,CAAC,GAAGD,KAAK,CAACE,IAAI,CAAC,CAAC","ignoreList":[]}

package/dist/PredicateX.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 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;
+/**
+ * Refines an `unknown` value to a plain `Record<string, unknown>` — `true` only
+ * for a non-null, non-array object whose prototype is `Object.prototype` (an
+ * object literal) or `null` (an `Object.create(null)` map).
+ *
+ * Effect ships no `Predicate.isRecord`. `Predicate.isObject` is the closest, but
+ * it also accepts `Map`, `Set`, `Date`, `RegExp`, and class instances. This guard
+ * adds a prototype check to rule those out, narrowing to `Record<string, unknown>`
+ * so the JSON-tree helpers (`RecordX.deepMerge`, `RecordX.canonicalize`,
+ * `RecordX.deleteByPath`) can compose without an `as` cast.
+ *
+ * It is named **`unsafe`** because the narrowing comes purely from the value's
+ * runtime shape — it does *not* validate the key or value types. A symbol-keyed
+ * entry still passes despite the `string` key claim, and values are asserted
+ * `unknown` without any check. Treat it as a structural convenience, not a
+ * `Schema` validation: reach for `Schema` when you need real key/value guarantees.
+ *
+ * @example
+ * ```ts
+ * import { PredicateX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord({ a: 1 }), true)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord(Object.create(null)), true)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord([1, 2]), false)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord(new Map()), false)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord(null), false)
+ * ```
+ *
+ * @category refinements
+ * @since 0.0.0
+ */
+export declare function unsafeIsRecord(value: unknown): value is Record<string, unknown>;
+//# 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;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMlC"}

package/dist/PredicateX.js

@@ -0,0 +1,111 @@
+/**
+ * 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);
+}
+/**
+ * Refines an `unknown` value to a plain `Record<string, unknown>` — `true` only
+ * for a non-null, non-array object whose prototype is `Object.prototype` (an
+ * object literal) or `null` (an `Object.create(null)` map).
+ *
+ * Effect ships no `Predicate.isRecord`. `Predicate.isObject` is the closest, but
+ * it also accepts `Map`, `Set`, `Date`, `RegExp`, and class instances. This guard
+ * adds a prototype check to rule those out, narrowing to `Record<string, unknown>`
+ * so the JSON-tree helpers (`RecordX.deepMerge`, `RecordX.canonicalize`,
+ * `RecordX.deleteByPath`) can compose without an `as` cast.
+ *
+ * It is named **`unsafe`** because the narrowing comes purely from the value's
+ * runtime shape — it does *not* validate the key or value types. A symbol-keyed
+ * entry still passes despite the `string` key claim, and values are asserted
+ * `unknown` without any check. Treat it as a structural convenience, not a
+ * `Schema` validation: reach for `Schema` when you need real key/value guarantees.
+ *
+ * @example
+ * ```ts
+ * import { PredicateX } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord({ a: 1 }), true)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord(Object.create(null)), true)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord([1, 2]), false)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord(new Map()), false)
+ * assert.deepStrictEqual(PredicateX.unsafeIsRecord(null), false)
+ * ```
+ *
+ * @category refinements
+ * @since 0.0.0
+ */
+export function unsafeIsRecord(value) {
+  if (!Predicate.isObject(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+//# 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","unsafeIsRecord","isObject","prototype","Object","getPrototypeOf"],"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;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAM,SAAUS,cAAcA,CAC5BT,KAAc;EAEd,IAAI,CAACJ,SAAS,CAACc,QAAQ,CAACV,KAAK,CAAC,EAAE;IAC9B,OAAO,KAAK;EACd;EACA,MAAMW,SAAS,GAAGC,MAAM,CAACC,cAAc,CAACb,KAAK,CAAC;EAC9C,OAAOW,SAAS,KAAKC,MAAM,CAACD,SAAS,IAAIA,SAAS,KAAK,IAAI;AAC7D","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":[]}