@nunofyobiz/effect-extras 2.0.0 → 2.1.0

package/dist/StructX.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Struct` module.
+ *
+ * @since 0.0.0
+ */
+import { Option } from "effect";
+/**
+ * Describes the shape of a per-field transformation over an object `O`: a record
+ * `T` whose values are functions taking the corresponding field of `O`.
+ *
+ * Used to type the "evolve" pattern, where each provided key maps to a function
+ * that receives that field's current value. Copied from Effect's internal
+ * `Struct.evolve()` type, which is not exported — it would be better to use
+ * theirs directly if it ever becomes public.
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * type Transform = StructX.PartialTransform<
+ *   { a: number; b: string },
+ *   { a: (n: number) => boolean }
+ * >
+ *
+ * const evolve: Transform = { a: (n) => n > 0 }
+ *
+ * assert.deepStrictEqual(evolve.a(1), true)
+ * ```
+ *
+ * @category models
+ * @since 0.0.0
+ */
+export type PartialTransform<O, T> = {
+    [K in keyof T]: T[K] extends (a: O[K & keyof O]) => unknown ? T[K] : (a: O[K & keyof O]) => unknown;
+};
+/**
+ * Builds a singleton record `{ [name]: value }` when `value` is defined, or an
+ * empty object `{}` when it is `undefined` — meant to be spread into an object
+ * literal.
+ *
+ * This is the canonical fix for `exactOptionalPropertyTypes: true` (which this
+ * repo enables for Effect Schema). Under that flag, spreading
+ * `{ key: maybeUndefined }` into an object whose key is `key?: T` is a type
+ * error: the property must be *absent*, not present-but-`undefined`. Spreading
+ * `...defined("key", maybeUndefined)` instead conditionally omits the property
+ * altogether. Note that `null` and other falsy-but-defined values (`0`, `""`,
+ * `false`) are kept — only `undefined` is dropped.
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Defined value → singleton record
+ * assert.deepStrictEqual(StructX.defined("name", "Ada"), { name: "Ada" })
+ *
+ * // undefined → property omitted entirely
+ * assert.deepStrictEqual(StructX.defined("name", undefined), {})
+ *
+ * // Falsy-but-defined values are kept
+ * assert.deepStrictEqual(StructX.defined("name", 0), { name: 0 })
+ *
+ * // Typical use: spread to conditionally include an optional field
+ * const maybeAge: number | undefined = undefined
+ * assert.deepStrictEqual({ id: 1, ...StructX.defined("age", maybeAge) }, {
+ *   id: 1,
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export declare const defined: <const K extends string, V>(name: K, value: V | undefined) => Partial<Record<K, Exclude<V, undefined>>>;
+/**
+ * Removes every property whose value is `undefined` from `record`, narrowing
+ * each remaining property type to exclude `undefined`.
+ *
+ * The bulk counterpart of {@link defined}: instead of building one optional
+ * field, it filters a whole object. Very useful for update/patch actions where
+ * `undefined` means "leave this field unchanged" while every other value —
+ * including `null`, `0`, `""`, `false`, and `Option.none()` — means "set the
+ * field to exactly this".
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Drops `b` (undefined) but keeps every other value, including null/0/false
+ * assert.deepStrictEqual(
+ *   StructX.filterDefined({ a: "x", b: undefined, c: 0, d: null, e: false }),
+ *   { a: "x", c: 0, d: null, e: false },
+ * )
+ * ```
+ *
+ * @category filtering
+ * @since 0.0.0
+ */
+export declare const filterDefined: <R extends Record<string, unknown>>(record: R) => Partial<{ [P in keyof R]: Exclude<R[P], undefined>; }>;
+/**
+ * Builds a singleton record `{ [name]: value }` when `value` is `Some`, or an
+ * empty object `{}` when it is `None` — meant to be spread into an object
+ * literal.
+ *
+ * The `Option`-valued sibling of {@link defined}: where `defined` keys off
+ * `undefined`, this keys off `Option` presence. Spread `...some("key", opt)` to
+ * conditionally include a field only when the `Option` carries a value, which
+ * stays correct under `exactOptionalPropertyTypes: true`.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "effect"
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Some → singleton record
+ * assert.deepStrictEqual(StructX.some("name", Option.some("Ada")), {
+ *   name: "Ada",
+ * })
+ *
+ * // None → property omitted entirely
+ * assert.deepStrictEqual(StructX.some("name", Option.none()), {})
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export declare const some: <const K extends string, V>(name: K, value: Option.Option<V>) => Partial<Record<K, V>>;
+/**
+ * Looks up `key` in a record of `Option` values and returns a singleton record
+ * when the value is `Some`, or `{}` when the key is absent or its value is
+ * `None`.
+ *
+ * Combines `Record.get` + `Option.flatten` + a singleton builder in one call —
+ * ideal for spreading an optional field out of a lookup table into an object
+ * literal under `exactOptionalPropertyTypes: true`. By default the output key
+ * matches the lookup key; pass `renameKeyTo` to emit the value under a different
+ * name.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "effect"
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * const lookup = {
+ *   a: Option.some(100),
+ *   b: Option.none<number>(),
+ * }
+ *
+ * // Some → singleton record under the same key
+ * assert.deepStrictEqual(StructX.pickSome(lookup, "a"), { a: 100 })
+ *
+ * // None → property omitted entirely
+ * assert.deepStrictEqual(StructX.pickSome(lookup, "b"), {})
+ *
+ * // Rename the output key
+ * assert.deepStrictEqual(StructX.pickSome(lookup, "a", "count"), { count: 100 })
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export declare function pickSome<const K extends string, V>(record: Record<K, Option.Option<V>>, key: K): Partial<Record<K, V>>;
+export declare function pickSome<const K1 extends string, V, const K2 extends string>(record: Record<K1, Option.Option<V>>, key: K1, renameKeyTo: K2): Partial<Record<K2, V>>;
+/**
+ * Builds a singleton record `{ [name]: value }` when `value` is truthy, or an
+ * empty object `{}` otherwise — meant to be spread into an object literal.
+ *
+ * Stricter than {@link defined}: it drops not just `undefined` but every falsy
+ * value (`null`, `false`, `0`, `""`, `NaN`), and narrows the value type
+ * accordingly. Use it to spread a field only when it carries a meaningful,
+ * non-falsy value.
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Truthy value → singleton record
+ * assert.deepStrictEqual(StructX.truthy("name", "Ada"), { name: "Ada" })
+ *
+ * // Falsy values → property omitted entirely
+ * assert.deepStrictEqual(StructX.truthy("name", ""), {})
+ * assert.deepStrictEqual(StructX.truthy("name", 0), {})
+ * assert.deepStrictEqual(StructX.truthy("name", false), {})
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export declare const truthy: <const K extends string, V>(name: K, value: V) => Partial<Record<K, Exclude<NonNullable<V>, false | 0 | "">>>;
+/**
+ * Returns `true` when `object` has `key` set to a non-nullish value, narrowing
+ * that property to `NonNullable` on the type level.
+ *
+ * A type guard combining `hasProperty` with a nullish check: after a successful
+ * test, TypeScript treats `object[key]` as present and free of `null` /
+ * `undefined`. Handy as a predicate passed to `Array.filter` to keep only the
+ * elements whose `key` is populated.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   StructX.hasNotNullableProperty({ id: "1" }, "id"),
+ *   true,
+ * )
+ *
+ * // data-last (pipeable); a null value fails the guard
+ * assert.deepStrictEqual(
+ *   pipe({ id: null }, StructX.hasNotNullableProperty("id")),
+ *   false,
+ * )
+ * ```
+ *
+ * @category refinements
+ * @since 0.0.0
+ */
+export declare const hasNotNullableProperty: (<T, K extends keyof T>(key: K) => (object: T) => object is T & Record<K, NonNullable<T[K]>>) & (<T, K extends keyof T>(object: T, key: K) => object is T & Record<K, NonNullable<T[K]>>);
+//# sourceMappingURL=StructX.d.ts.map

package/dist/StructX.d.ts.map

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

package/dist/StructX.js

@@ -0,0 +1,173 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Struct` module.
+ *
+ * @since 0.0.0
+ */
+import { Option, Predicate, Record, pipe } from "effect";
+import { dual } from "effect/Function";
+/**
+ * Builds a singleton record `{ [name]: value }` when `value` is defined, or an
+ * empty object `{}` when it is `undefined` — meant to be spread into an object
+ * literal.
+ *
+ * This is the canonical fix for `exactOptionalPropertyTypes: true` (which this
+ * repo enables for Effect Schema). Under that flag, spreading
+ * `{ key: maybeUndefined }` into an object whose key is `key?: T` is a type
+ * error: the property must be *absent*, not present-but-`undefined`. Spreading
+ * `...defined("key", maybeUndefined)` instead conditionally omits the property
+ * altogether. Note that `null` and other falsy-but-defined values (`0`, `""`,
+ * `false`) are kept — only `undefined` is dropped.
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Defined value → singleton record
+ * assert.deepStrictEqual(StructX.defined("name", "Ada"), { name: "Ada" })
+ *
+ * // undefined → property omitted entirely
+ * assert.deepStrictEqual(StructX.defined("name", undefined), {})
+ *
+ * // Falsy-but-defined values are kept
+ * assert.deepStrictEqual(StructX.defined("name", 0), { name: 0 })
+ *
+ * // Typical use: spread to conditionally include an optional field
+ * const maybeAge: number | undefined = undefined
+ * assert.deepStrictEqual({ id: 1, ...StructX.defined("age", maybeAge) }, {
+ *   id: 1,
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const defined = (name, value) => Predicate.isUndefined(value) ? {} : Record.singleton(name, value);
+/**
+ * Removes every property whose value is `undefined` from `record`, narrowing
+ * each remaining property type to exclude `undefined`.
+ *
+ * The bulk counterpart of {@link defined}: instead of building one optional
+ * field, it filters a whole object. Very useful for update/patch actions where
+ * `undefined` means "leave this field unchanged" while every other value —
+ * including `null`, `0`, `""`, `false`, and `Option.none()` — means "set the
+ * field to exactly this".
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Drops `b` (undefined) but keeps every other value, including null/0/false
+ * assert.deepStrictEqual(
+ *   StructX.filterDefined({ a: "x", b: undefined, c: 0, d: null, e: false }),
+ *   { a: "x", c: 0, d: null, e: false },
+ * )
+ * ```
+ *
+ * @category filtering
+ * @since 0.0.0
+ */
+export const filterDefined = record => Object.entries(record).reduce((accumulator, [key, value]) => ({
+  ...accumulator,
+  ...defined(key, value)
+}), {});
+/**
+ * Builds a singleton record `{ [name]: value }` when `value` is `Some`, or an
+ * empty object `{}` when it is `None` — meant to be spread into an object
+ * literal.
+ *
+ * The `Option`-valued sibling of {@link defined}: where `defined` keys off
+ * `undefined`, this keys off `Option` presence. Spread `...some("key", opt)` to
+ * conditionally include a field only when the `Option` carries a value, which
+ * stays correct under `exactOptionalPropertyTypes: true`.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "effect"
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Some → singleton record
+ * assert.deepStrictEqual(StructX.some("name", Option.some("Ada")), {
+ *   name: "Ada",
+ * })
+ *
+ * // None → property omitted entirely
+ * assert.deepStrictEqual(StructX.some("name", Option.none()), {})
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const some = (name, value) => Option.match(value, {
+  onSome: someValue => Record.singleton(name, someValue),
+  onNone: () => ({})
+});
+/**
+ * Like {@link some}, but with swapped argument order for piping. Returns a
+ * singleton record `{ [name]: value }` when the Option is `Some`, or an
+ * empty object `{}` when `None`.
+ *
+ * Internal-only — exists to support {@link pickSome} in data-last form.
+ * Not exported because the codebase has no direct callers.
+ */
+const someSingleton = /*#__PURE__*/dual(2, (value, name) => some(name, value));
+export function pickSome(record, key, renameKeyTo) {
+  return pipe(Record.get(record, key), Option.flatten, someSingleton(renameKeyTo ?? key));
+}
+/**
+ * Builds a singleton record `{ [name]: value }` when `value` is truthy, or an
+ * empty object `{}` otherwise — meant to be spread into an object literal.
+ *
+ * Stricter than {@link defined}: it drops not just `undefined` but every falsy
+ * value (`null`, `false`, `0`, `""`, `NaN`), and narrows the value type
+ * accordingly. Use it to spread a field only when it carries a meaningful,
+ * non-falsy value.
+ *
+ * @example
+ * ```ts
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // Truthy value → singleton record
+ * assert.deepStrictEqual(StructX.truthy("name", "Ada"), { name: "Ada" })
+ *
+ * // Falsy values → property omitted entirely
+ * assert.deepStrictEqual(StructX.truthy("name", ""), {})
+ * assert.deepStrictEqual(StructX.truthy("name", 0), {})
+ * assert.deepStrictEqual(StructX.truthy("name", false), {})
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const truthy = (name, value) => Predicate.isTruthy(value) ? Record.singleton(name, value) : {};
+/**
+ * Returns `true` when `object` has `key` set to a non-nullish value, narrowing
+ * that property to `NonNullable` on the type level.
+ *
+ * A type guard combining `hasProperty` with a nullish check: after a successful
+ * test, TypeScript treats `object[key]` as present and free of `null` /
+ * `undefined`. Handy as a predicate passed to `Array.filter` to keep only the
+ * elements whose `key` is populated.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StructX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(
+ *   StructX.hasNotNullableProperty({ id: "1" }, "id"),
+ *   true,
+ * )
+ *
+ * // data-last (pipeable); a null value fails the guard
+ * assert.deepStrictEqual(
+ *   pipe({ id: null }, StructX.hasNotNullableProperty("id")),
+ *   false,
+ * )
+ * ```
+ *
+ * @category refinements
+ * @since 0.0.0
+ */
+export const hasNotNullableProperty = /*#__PURE__*/dual(2, (object, key) => Predicate.hasProperty(object, key) && Predicate.isNotNullish(object[key]));
+//# sourceMappingURL=StructX.js.map

package/dist/StructX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructX.js","names":["Option","Predicate","Record","pipe","dual","defined","name","value","isUndefined","singleton","filterDefined","record","Object","entries","reduce","accumulator","key","some","match","onSome","someValue","onNone","someSingleton","pickSome","renameKeyTo","get","flatten","truthy","isTruthy","hasNotNullableProperty","object","hasProperty","isNotNullish"],"sources":["../src/StructX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,MAAM,EAAEC,SAAS,EAAEC,MAAM,EAAEC,IAAI,QAAQ,QAAQ;AACxD,SAASC,IAAI,QAAQ,iBAAiB;AAkCtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,OAAO,MAAMC,OAAO,GAAGA,CACrBC,IAAO,EACPC,KAAoB,KAEpBN,SAAS,CAACO,WAAW,CAACD,KAAK,CAAC,GACxB,EAAE,GACFL,MAAM,CAACO,SAAS,CAACH,IAAI,EAAEC,KAA8B,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMG,aAAa,GACxBC,MAAS,IAETC,MAAM,CAACC,OAAO,CAACF,MAAM,CAAC,CAACG,MAAM,CAC3B,CAACC,WAAW,EAAE,CAACC,GAAG,EAAET,KAAK,CAAC,MAAM;EAAE,GAAGQ,WAAW;EAAE,GAAGV,OAAO,CAACW,GAAG,EAAET,KAAK;AAAC,CAAE,CAAC,EAC3E,EAA2D,CAC5D;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,MAAMU,IAAI,GAAGA,CAClBX,IAAO,EACPC,KAAuB,KAEvBP,MAAM,CAACkB,KAAK,CAACX,KAAK,EAAE;EAClBY,MAAM,EAAGC,SAAS,IAAKlB,MAAM,CAACO,SAAS,CAACH,IAAI,EAAEc,SAAS,CAAC;EACxDC,MAAM,EAAEA,CAAA,MAAO,EAAE;CAClB,CAAC;AAEJ;;;;;;;;AAQA,MAAMC,aAAa,gBAQflB,IAAI,CACN,CAAC,EACD,CACEG,KAAuB,EACvBD,IAAO,KACmBW,IAAI,CAACX,IAAI,EAAEC,KAAK,CAAC,CAC9C;AA6CD,OAAM,SAAUgB,QAAQA,CACtBZ,MAAoC,EACpCK,GAAO,EACPQ,WAAgB;EAEhB,OAAOrB,IAAI,CACTD,MAAM,CAACuB,GAAG,CAACd,MAAM,EAAEK,GAAG,CAAC,EACvBhB,MAAM,CAAC0B,OAAO,EACdJ,aAAa,CAACE,WAAW,IAAIR,GAAG,CAAC,CAClC;AACH;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMW,MAAM,GAAGA,CACpBrB,IAAO,EACPC,KAAQ,KAERN,SAAS,CAAC2B,QAAQ,CAACrB,KAAK,CAAC,GACrBL,MAAM,CAACO,SAAS,CAACH,IAAI,EAAEC,KAAgD,CAAC,GACxE,EAAE;AAER;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMsB,sBAAsB,gBAAGzB,IAAI,CASxC,CAAC,EACD,CACE0B,MAAS,EACTd,GAAM,KAENf,SAAS,CAAC8B,WAAW,CAACD,MAAM,EAAEd,GAAG,CAAC,IAAIf,SAAS,CAAC+B,YAAY,CAACF,MAAM,CAACd,GAAG,CAAC,CAAC,CAC5E","ignoreList":[]}