@nunofyobiz/effect-extras 2.0.0 → 2.1.0

package/dist/SchemaX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaX.d.ts","sourceRoot":"","sources":["../src/SchemaX.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAU,MAAM,EAAwB,MAAM,QAAQ,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,qBAAqB,4FAKjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,eAAe,sOAK3B,CAAC;AAaF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,iBAAiB,GAxC3B,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,uDAwCM,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;CAAE,IAChE,CAAC,CAAC,eAAe,CAAC,CAAC;AAQrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EACzC,KAAK,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,EAErD,QAAQ,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAC7B,GAAG,MAAM,IAAI,KACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAOxC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EACzC,KAAK,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,EAErD,QAAQ,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAC7B,GAAG,MAAM,IAAI,KACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAOxC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EACzD,QAAQ,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAE,CAOhE,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EACzC,KAAK,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,EAErD,QAAQ,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAC7B,GAAG,MAAM,IAAI,KACZ,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAE,CACpC,CAAC"}

package/dist/SchemaX.js

@@ -0,0 +1,243 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Schema` module.
+ *
+ * @since 0.0.0
+ */
+import { BigInt, Schema, SchemaGetter, Struct } from "effect";
+/**
+ * A `Schema` for a non-empty string that is trimmed on both decode and encode.
+ *
+ * Leading and trailing whitespace is stripped, and the resulting value must be
+ * non-empty — so a whitespace-only input (e.g. `"   "`) fails the
+ * `NonEmptyString` refinement after trimming. Use it wherever user-supplied text
+ * should be normalized and guaranteed to carry content.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const decoded = Effect.runSync(
+ *   Schema.decodeEffect(SchemaX.TrimmedNonEmptyString)("  hello  "),
+ * )
+ * assert.deepStrictEqual(decoded, "hello")
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const TrimmedNonEmptyString = /*#__PURE__*/Schema.NonEmptyString.pipe(/*#__PURE__*/Schema.decode({
+  decode: /*#__PURE__*/SchemaGetter.transform(s => s.trim()),
+  encode: /*#__PURE__*/SchemaGetter.transform(s => s.trim())
+}));
+/**
+ * A `Schema` for a URL-safe file path built on top of {@link
+ * TrimmedNonEmptyString}.
+ *
+ * On decode the path is `decodeURIComponent`-ed (percent-escapes are expanded);
+ * on encode it is `encodeURIComponent`-ed back into its URL-safe form. The
+ * underlying value is also trimmed and required to be non-empty. Use it at the
+ * boundary between stored/transmitted encoded paths and the decoded paths your
+ * code works with.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * // Decoding expands percent-escapes
+ * const decoded = Effect.runSync(
+ *   Schema.decodeEffect(SchemaX.URLSafeFilePath)("a%2Fb.txt"),
+ * )
+ * assert.deepStrictEqual(decoded, "a/b.txt")
+ *
+ * // Encoding produces the URL-safe form
+ * const encoded = Effect.runSync(
+ *   Schema.encodeEffect(SchemaX.URLSafeFilePath)("a/b.txt"),
+ * )
+ * assert.deepStrictEqual(encoded, "a%2Fb.txt")
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const URLSafeFilePath = /*#__PURE__*/TrimmedNonEmptyString.pipe(/*#__PURE__*/Schema.decode({
+  decode: /*#__PURE__*/SchemaGetter.transform(path => decodeURIComponent(path)),
+  encode: /*#__PURE__*/SchemaGetter.transform(path => encodeURIComponent(path))
+}));
+// Internal — only used to construct nonNegativeBigInt below.
+const clampMinBigInt = min => schema => schema.pipe(Schema.decode({
+  decode: SchemaGetter.transform(value => BigInt.max(value, min)),
+  encode: SchemaGetter.transform(value => BigInt.max(value, min))
+}));
+/**
+ * Transforms a `bigint` `Schema` so its value is clamped to be non-negative,
+ * mapping any value below `0n` up to `0n` on both decode and encode.
+ *
+ * Unlike a refinement that *rejects* negative input, this *coerces* it: a
+ * negative `bigint` decodes to `0n` rather than failing. Apply it to a `bigint`
+ * schema whenever negative magnitudes are meaningless and should be floored at
+ * zero rather than treated as errors.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const NonNegative = SchemaX.nonNegativeBigInt(Schema.BigInt)
+ *
+ * // Negative values are clamped up to 0n
+ * assert.deepStrictEqual(
+ *   Effect.runSync(Schema.decodeEffect(NonNegative)(-5n)),
+ *   0n,
+ * )
+ *
+ * // Non-negative values pass through unchanged
+ * assert.deepStrictEqual(
+ *   Effect.runSync(Schema.decodeEffect(NonNegative)(7n)),
+ *   7n,
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const nonNegativeBigInt = /*#__PURE__*/clampMinBigInt(0n);
+// ---------------------------------------------------------------------------
+// Schema.Struct utilities — v4 removed the `.pick(...)`, `.omit(...)`, and
+// `Schema.partial(...)` methods that v3 had on `Schema.Struct` instances. These
+// helpers restore the same ergonomics on top of v4's `mapFields` primitive.
+// ---------------------------------------------------------------------------
+/**
+ * Returns a new `Schema.Struct` containing only the named `keys` of `schema`.
+ *
+ * Restores the v3 ergonomics of `mySchema.pick("a", "b")` — v4 removed the
+ * `.pick(...)` method from `Schema.Struct` instances, so this rebuilds it on top
+ * of v4's `mapFields` primitive. Each picked field keeps its original schema,
+ * including any refinements.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const Source = Schema.Struct({
+ *   a: Schema.Number,
+ *   b: Schema.String,
+ *   c: Schema.Boolean,
+ * })
+ *
+ * const Picked = SchemaX.pick(Source, "a", "b")
+ *
+ * const decoded = Effect.runSync(
+ *   Schema.decodeEffect(Picked)({ a: 1, b: "hi" }),
+ * )
+ * assert.deepStrictEqual(decoded, { a: 1, b: "hi" })
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const pick = (schema, ...keys) => schema.mapFields(fields => Struct.pick(fields, keys));
+/**
+ * Returns a new `Schema.Struct` with the named `keys` of `schema` removed.
+ *
+ * The complement of {@link pick}, restoring the v3 ergonomics of
+ * `mySchema.omit("a")` that v4 dropped from `Schema.Struct` instances. Every
+ * surviving field keeps its original schema, including any refinements.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const Source = Schema.Struct({
+ *   a: Schema.Number,
+ *   b: Schema.String,
+ *   c: Schema.Boolean,
+ * })
+ *
+ * const Omitted = SchemaX.omit(Source, "c")
+ *
+ * const decoded = Effect.runSync(
+ *   Schema.decodeEffect(Omitted)({ a: 1, b: "hi" }),
+ * )
+ * assert.deepStrictEqual(decoded, { a: 1, b: "hi" })
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const omit = (schema, ...keys) => schema.mapFields(fields => Struct.omit(fields, keys));
+/**
+ * Returns a new `Schema.Struct` in which every field of `schema` is made
+ * optional.
+ *
+ * Restores the v3 `Schema.partial(mySchema)` behaviour that v4 removed, by
+ * wrapping each field in `Schema.optional`. A decoded value may therefore omit
+ * any field; fields that *are* present still have to satisfy their original
+ * schema, refinements included.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const Source = Schema.Struct({ a: Schema.Number, b: Schema.String })
+ * const Partial = SchemaX.partial(Source)
+ *
+ * // All fields may be absent
+ * assert.deepStrictEqual(Effect.runSync(Schema.decodeEffect(Partial)({})), {})
+ *
+ * // A present subset still decodes
+ * assert.deepStrictEqual(
+ *   Effect.runSync(Schema.decodeEffect(Partial)({ a: 1 })),
+ *   { a: 1 },
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const partial = schema => schema.mapFields(fields => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = Schema.optional(fields[key]);
+  }
+  return result;
+});
+/**
+ * Returns a new `Schema.Struct` containing only the named `keys` of `schema`,
+ * with every picked field made optional.
+ *
+ * Equivalent to `partial(pick(schema, ...keys))`, but reads more directly for
+ * the common "partial update over a subset of fields" pattern: select the
+ * mutable fields of an entity, then allow any of them to be omitted in the
+ * update payload. Composes {@link pick} and {@link partial} in one call.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const Source = Schema.Struct({
+ *   a: Schema.Number,
+ *   b: Schema.String,
+ *   c: Schema.Boolean,
+ * })
+ *
+ * const Update = SchemaX.pickPartial(Source, "a", "b")
+ *
+ * // Only picked fields are known, and each may be omitted
+ * assert.deepStrictEqual(Effect.runSync(Schema.decodeEffect(Update)({})), {})
+ * assert.deepStrictEqual(
+ *   Effect.runSync(Schema.decodeEffect(Update)({ a: 1 })),
+ *   { a: 1 },
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const pickPartial = (schema, ...keys) => partial(pick(schema, ...keys));
+//# sourceMappingURL=SchemaX.js.map

package/dist/SchemaX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaX.js","names":["BigInt","Schema","SchemaGetter","Struct","TrimmedNonEmptyString","NonEmptyString","pipe","decode","transform","s","trim","encode","URLSafeFilePath","path","decodeURIComponent","encodeURIComponent","clampMinBigInt","min","schema","value","max","nonNegativeBigInt","pick","keys","mapFields","fields","omit","partial","result","key","Object","optional","pickPartial"],"sources":["../src/SchemaX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,MAAM,EAAEC,MAAM,EAAEC,YAAY,EAAEC,MAAM,QAAQ,QAAQ;AAE7D;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAMC,qBAAqB,gBAAGH,MAAM,CAACI,cAAc,CAACC,IAAI,cAC7DL,MAAM,CAACM,MAAM,CAAC;EACZA,MAAM,eAAEL,YAAY,CAACM,SAAS,CAAEC,CAAC,IAAKA,CAAC,CAACC,IAAI,EAAE,CAAC;EAC/CC,MAAM,eAAET,YAAY,CAACM,SAAS,CAAEC,CAAC,IAAKA,CAAC,CAACC,IAAI,EAAE;CAC/C,CAAC,CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAME,eAAe,gBAAGR,qBAAqB,CAACE,IAAI,cACvDL,MAAM,CAACM,MAAM,CAAC;EACZA,MAAM,eAAEL,YAAY,CAACM,SAAS,CAAEK,IAAI,IAAKC,kBAAkB,CAACD,IAAI,CAAC,CAAC;EAClEF,MAAM,eAAET,YAAY,CAACM,SAAS,CAAEK,IAAI,IAAKE,kBAAkB,CAACF,IAAI,CAAC;CAClE,CAAC,CACH;AAED;AACA,MAAMG,cAAc,GACjBC,GAAW,IACsBC,MAAS,IACzCA,MAAM,CAACZ,IAAI,CACTL,MAAM,CAACM,MAAM,CAAC;EACZA,MAAM,EAAEL,YAAY,CAACM,SAAS,CAAEW,KAAK,IAAKnB,MAAM,CAACoB,GAAG,CAACD,KAAK,EAAEF,GAAG,CAAC,CAAC;EACjEN,MAAM,EAAET,YAAY,CAACM,SAAS,CAAEW,KAAK,IAAKnB,MAAM,CAACoB,GAAG,CAACD,KAAK,EAAEF,GAAG,CAAC;CACjE,CAAC,CACH;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,MAAMI,iBAAiB,gBAAGL,cAAc,CAAC,EAAE,CAAC;AA8BnD;AACA;AACA;AACA;AACA;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMM,IAAI,GAAGA,CAIlBJ,MAA6B,EAC7B,GAAGK,IAAU,KAEbL,MAAM,CAACM,SAAS,CACbC,MAAM,IACLtB,MAAM,CAACmB,IAAI,CAACG,MAAM,EAAEF,IAAiC,CAGpD,CACJ;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAO,MAAMG,IAAI,GAAGA,CAIlBR,MAA6B,EAC7B,GAAGK,IAAU,KAEbL,MAAM,CAACM,SAAS,CACbC,MAAM,IACLtB,MAAM,CAACuB,IAAI,CAACD,MAAM,EAAEF,IAAiC,CAGpD,CACJ;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMI,OAAO,GAClBT,MAA6B,IAE7BA,MAAM,CAACM,SAAS,CAAEC,MAAM,IAAI;EAC1B,MAAMG,MAAM,GAAyD,EAAE;EACvE,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACP,IAAI,CAACE,MAAM,CAAqB,EAAE;IACzDG,MAAM,CAACC,GAAG,CAAC,GAAG5B,MAAM,CAAC8B,QAAQ,CAACN,MAAM,CAACI,GAAG,CAAC,CAAC;EAC5C;EACA,OAAOD,MAA6D;AACtE,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,OAAO,MAAMI,WAAW,GAAGA,CAIzBd,MAA6B,EAC7B,GAAGK,IAAU,KAEbI,OAAO,CAACL,IAAI,CAACJ,MAAM,EAAE,GAAGK,IAAI,CAAC,CAAC","ignoreList":[]}

package/dist/SetX.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Runs a mutating function against a copy of `set`, leaving the original
+ * untouched, and returns the mutated copy.
+ *
+ * Use it to reuse imperative `Set` mutation code (`.add`, `.delete`) without
+ * sacrificing immutability: the callback may freely mutate the set it receives
+ * because it operates on a fresh clone. Supports both data-first and data-last
+ * (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * const original = new Set(["a", "b"])
+ *
+ * const result = pipe(
+ *   original,
+ *   SetX.safelyMutate((set) => {
+ *     set.delete("a")
+ *     return set.add("c")
+ *   })
+ * )
+ *
+ * assert.deepStrictEqual(result, new Set(["b", "c"]))
+ * // The original is left intact
+ * assert.deepStrictEqual(original, new Set(["a", "b"]))
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const safelyMutate: (<A>(mutate: (set: Set<A>) => Set<A>) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, mutate: (set: Set<A>) => Set<A>) => Set<A>);
+/**
+ * Returns a new `Set` with `value` added, leaving the input set unchanged.
+ *
+ * When `value` is already present the input set is returned as-is (no copy),
+ * making repeated adds of existing members allocation-free. Supports both
+ * data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — adds a new element into a fresh set
+ * assert.deepStrictEqual(
+ *   SetX.add(new Set(["a", "b"]), "c"),
+ *   new Set(["a", "b", "c"])
+ * )
+ *
+ * // Data-last — existing element leaves the set unchanged
+ * assert.deepStrictEqual(
+ *   pipe(new Set(["a", "b"]), SetX.add("b")),
+ *   new Set(["a", "b"])
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const add: (<A>(value: A) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, value: A) => Set<A>);
+/**
+ * Returns a new `Set` with `value` removed, leaving the input set unchanged.
+ *
+ * When `value` is absent the input set is returned as-is (no copy). Supports both
+ * data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — removes an existing element into a fresh set
+ * assert.deepStrictEqual(
+ *   SetX.remove(new Set(["a", "b", "c"]), "c"),
+ *   new Set(["a", "b"])
+ * )
+ *
+ * // Data-last — absent element leaves the set unchanged
+ * assert.deepStrictEqual(
+ *   pipe(new Set(["a", "b"]), SetX.remove("z")),
+ *   new Set(["a", "b"])
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const remove: (<A>(value: A) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, value: A) => Set<A>);
+/**
+ * Returns a new `Set` with `value` added if it was absent or removed if it was
+ * present, leaving the input set unchanged.
+ *
+ * Use it for membership toggles (selection state, feature flags by key) where a
+ * value's presence should flip on each call. Supports both data-first and
+ * data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — absent value gets added
+ * assert.deepStrictEqual(
+ *   SetX.toggle(new Set(["a", "b"]), "c"),
+ *   new Set(["a", "b", "c"])
+ * )
+ *
+ * // Data-last — present value gets removed
+ * assert.deepStrictEqual(
+ *   pipe(new Set(["a", "b", "c"]), SetX.toggle("b")),
+ *   new Set(["a", "c"])
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const toggle: (<A>(value: A) => (set: Set<A>) => Set<A>) & (<A>(set: Set<A>, value: A) => Set<A>);
+//# sourceMappingURL=SetX.d.ts.map

package/dist/SetX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SetX.d.ts","sourceRoot":"","sources":["../src/SetX.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,YAAY,IACtB,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MAC9D,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAI3D,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,GAAG,IACb,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MACvC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAKrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM,IAChB,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MACvC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAQpC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,MAAM,IAChB,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MACvC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAKrC,CAAC"}

package/dist/SetX.js

@@ -0,0 +1,137 @@
+/**
+ * Generic, framework-agnostic extensions for working with `Set`.
+ *
+ * @since 0.0.0
+ */
+import { dual } from "effect/Function";
+/**
+ * Runs a mutating function against a copy of `set`, leaving the original
+ * untouched, and returns the mutated copy.
+ *
+ * Use it to reuse imperative `Set` mutation code (`.add`, `.delete`) without
+ * sacrificing immutability: the callback may freely mutate the set it receives
+ * because it operates on a fresh clone. Supports both data-first and data-last
+ * (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * const original = new Set(["a", "b"])
+ *
+ * const result = pipe(
+ *   original,
+ *   SetX.safelyMutate((set) => {
+ *     set.delete("a")
+ *     return set.add("c")
+ *   })
+ * )
+ *
+ * assert.deepStrictEqual(result, new Set(["b", "c"]))
+ * // The original is left intact
+ * assert.deepStrictEqual(original, new Set(["a", "b"]))
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const safelyMutate = /*#__PURE__*/dual(2, (set, mutate) => {
+  const copy = new Set(set);
+  return mutate(copy);
+});
+/**
+ * Returns a new `Set` with `value` added, leaving the input set unchanged.
+ *
+ * When `value` is already present the input set is returned as-is (no copy),
+ * making repeated adds of existing members allocation-free. Supports both
+ * data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — adds a new element into a fresh set
+ * assert.deepStrictEqual(
+ *   SetX.add(new Set(["a", "b"]), "c"),
+ *   new Set(["a", "b", "c"])
+ * )
+ *
+ * // Data-last — existing element leaves the set unchanged
+ * assert.deepStrictEqual(
+ *   pipe(new Set(["a", "b"]), SetX.add("b")),
+ *   new Set(["a", "b"])
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const add = /*#__PURE__*/dual(2, (set, value) => set.has(value) ? set : new Set(set).add(value));
+/**
+ * Returns a new `Set` with `value` removed, leaving the input set unchanged.
+ *
+ * When `value` is absent the input set is returned as-is (no copy). Supports both
+ * data-first and data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — removes an existing element into a fresh set
+ * assert.deepStrictEqual(
+ *   SetX.remove(new Set(["a", "b", "c"]), "c"),
+ *   new Set(["a", "b"])
+ * )
+ *
+ * // Data-last — absent element leaves the set unchanged
+ * assert.deepStrictEqual(
+ *   pipe(new Set(["a", "b"]), SetX.remove("z")),
+ *   new Set(["a", "b"])
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const remove = /*#__PURE__*/dual(2, (set, value) => {
+  if (set.has(value)) {
+    const newSet = new Set(set);
+    newSet.delete(value);
+    return newSet;
+  }
+  return set;
+});
+/**
+ * Returns a new `Set` with `value` added if it was absent or removed if it was
+ * present, leaving the input set unchanged.
+ *
+ * Use it for membership toggles (selection state, feature flags by key) where a
+ * value's presence should flip on each call. Supports both data-first and
+ * data-last (pipeable) call styles.
+ *
+ * @example
+ * ```ts
+ * import { SetX } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * // Data-first — absent value gets added
+ * assert.deepStrictEqual(
+ *   SetX.toggle(new Set(["a", "b"]), "c"),
+ *   new Set(["a", "b", "c"])
+ * )
+ *
+ * // Data-last — present value gets removed
+ * assert.deepStrictEqual(
+ *   pipe(new Set(["a", "b", "c"]), SetX.toggle("b")),
+ *   new Set(["a", "c"])
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const toggle = /*#__PURE__*/dual(2, (set, value) => set.has(value) ? remove(set, value) : add(set, value));
+//# sourceMappingURL=SetX.js.map

package/dist/SetX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SetX.js","names":["dual","safelyMutate","set","mutate","copy","Set","add","value","has","remove","newSet","delete","toggle"],"sources":["../src/SetX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,MAAMC,YAAY,gBAAGD,IAAI,CAG9B,CAAC,EAAE,CAAIE,GAAW,EAAEC,MAA+B,KAAY;EAC/D,MAAMC,IAAI,GAAG,IAAIC,GAAG,CAACH,GAAG,CAAC;EACzB,OAAOC,MAAM,CAACC,IAAI,CAAC;AACrB,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAO,MAAME,GAAG,gBAAGN,IAAI,CAIrB,CAAC,EACD,CAAIE,GAAW,EAAEK,KAAQ,KACvBL,GAAG,CAACM,GAAG,CAACD,KAAK,CAAC,GAAGL,GAAG,GAAG,IAAIG,GAAG,CAACH,GAAG,CAAC,CAACI,GAAG,CAACC,KAAK,CAAC,CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,MAAME,MAAM,gBAAGT,IAAI,CAGxB,CAAC,EAAE,CAAIE,GAAW,EAAEK,KAAQ,KAAY;EACxC,IAAIL,GAAG,CAACM,GAAG,CAACD,KAAK,CAAC,EAAE;IAClB,MAAMG,MAAM,GAAG,IAAIL,GAAG,CAACH,GAAG,CAAC;IAC3BQ,MAAM,CAACC,MAAM,CAACJ,KAAK,CAAC;IACpB,OAAOG,MAAM;EACf;EACA,OAAOR,GAAG;AACZ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAO,MAAMU,MAAM,gBAAGZ,IAAI,CAIxB,CAAC,EACD,CAAIE,GAAW,EAAEK,KAAQ,KACvBL,GAAG,CAACM,GAAG,CAACD,KAAK,CAAC,GAAGE,MAAM,CAACP,GAAG,EAAEK,KAAK,CAAC,GAAGD,GAAG,CAACJ,GAAG,EAAEK,KAAK,CAAC,CACxD","ignoreList":[]}

package/dist/StringX.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Prepends `start` to `string_`.
+ *
+ * v4's `String` module has no native `prepend` (only `concat`), so this fills
+ * the gap as a pipeable helper.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(StringX.prepend("world", "hello "), "hello world")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("world", StringX.prepend("hello ")), "hello world")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const prepend: ((start: string) => (string_: string) => string) & ((string_: string, start: string) => string);
+/**
+ * Wraps `string_` between `start` and `end`.
+ *
+ * No v4 native equivalent — handy for quoting, bracketing, or fencing a value.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(StringX.surround("value", "[", "]"), "[value]")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("value", StringX.surround("(", ")")), "(value)")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const surround: ((start: string, end: string) => (string_: string) => string) & ((string_: string, start: string, end: string) => string);
+/**
+ * Prepends `start` to `string_` unless `string_` already starts with it.
+ *
+ * Idempotent: applying it to an already-prefixed string is a no-op, so
+ * `ensurePrepend("foofoo", "foo")` stays `"foofoo"` rather than gaining a
+ * second `"foo"`.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first — adds the prefix when missing
+ * assert.deepStrictEqual(StringX.ensurePrepend("bar", "foo"), "foobar")
+ *
+ * // idempotent — already prefixed, returned unchanged
+ * assert.deepStrictEqual(StringX.ensurePrepend("foobar", "foo"), "foobar")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("bar", StringX.ensurePrepend("foo")), "foobar")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const ensurePrepend: ((start: string) => (string_: string) => string) & ((string_: string, start: string) => string);
+//# sourceMappingURL=StringX.d.ts.map

package/dist/StringX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringX.d.ts","sourceRoot":"","sources":["../src/StringX.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO,WACV,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACpC,MAAM,SAAS,MAAM,KAAK,MAAM,CAC0B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,OAAO,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACjD,MAAM,SAAS,MAAM,OAAO,MAAM,KAAK,MAAM,CAKxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,WAChB,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACpC,MAAM,SAAS,MAAM,KAAK,MAAM,CAO1C,CAAC"}

package/dist/StringX.js

@@ -0,0 +1,81 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `String` module.
+ *
+ * @since 0.0.0
+ */
+import { dual } from "effect/Function";
+/**
+ * Prepends `start` to `string_`.
+ *
+ * v4's `String` module has no native `prepend` (only `concat`), so this fills
+ * the gap as a pipeable helper.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(StringX.prepend("world", "hello "), "hello world")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("world", StringX.prepend("hello ")), "hello world")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const prepend = /*#__PURE__*/dual(2, (string_, start) => `${start}${string_}`);
+/**
+ * Wraps `string_` between `start` and `end`.
+ *
+ * No v4 native equivalent — handy for quoting, bracketing, or fencing a value.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first
+ * assert.deepStrictEqual(StringX.surround("value", "[", "]"), "[value]")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("value", StringX.surround("(", ")")), "(value)")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const surround = /*#__PURE__*/dual(3, (string_, start, end) => `${start}${string_}${end}`);
+/**
+ * Prepends `start` to `string_` unless `string_` already starts with it.
+ *
+ * Idempotent: applying it to an already-prefixed string is a no-op, so
+ * `ensurePrepend("foofoo", "foo")` stays `"foofoo"` rather than gaining a
+ * second `"foo"`.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first — adds the prefix when missing
+ * assert.deepStrictEqual(StringX.ensurePrepend("bar", "foo"), "foobar")
+ *
+ * // idempotent — already prefixed, returned unchanged
+ * assert.deepStrictEqual(StringX.ensurePrepend("foobar", "foo"), "foobar")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("bar", StringX.ensurePrepend("foo")), "foobar")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const ensurePrepend = /*#__PURE__*/dual(2, (string_, start) => {
+  if (string_.startsWith(start)) {
+    return string_;
+  }
+  return `${start}${string_}`;
+});
+//# sourceMappingURL=StringX.js.map

package/dist/StringX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringX.js","names":["dual","prepend","string_","start","surround","end","ensurePrepend","startsWith"],"sources":["../src/StringX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,OAAO,gBAAGD,IAAI,CAGzB,CAAC,EAAE,CAACE,OAAe,EAAEC,KAAa,KAAa,GAAGA,KAAK,GAAGD,OAAO,EAAE,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAME,QAAQ,gBAAGJ,IAAI,CAI1B,CAAC,EACD,CAACE,OAAe,EAAEC,KAAa,EAAEE,GAAW,KAC1C,GAAGF,KAAK,GAAGD,OAAO,GAAGG,GAAG,EAAE,CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,aAAa,gBAAGN,IAAI,CAG/B,CAAC,EAAE,CAACE,OAAe,EAAEC,KAAa,KAAY;EAC9C,IAAID,OAAO,CAACK,UAAU,CAACJ,KAAK,CAAC,EAAE;IAC7B,OAAOD,OAAO;EAChB;EAEA,OAAO,GAAGC,KAAK,GAAGD,OAAO,EAAE;AAC7B,CAAC,CAAC","ignoreList":[]}