@nunofyobiz/effect-extras 2.0.0 → 3.0.0

package/dist/SchemaX.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Generic, framework-agnostic extensions to Effect's `Schema` module.
+ *
+ * @since 0.0.0
+ */
+import { Schema } 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 declare const TrimmedNonEmptyString: Schema.decodeTo<Schema.toType<Schema.NonEmptyString>, Schema.NonEmptyString, never, never>;
+/**
+ * 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 declare const URLSafeFilePath: Schema.decodeTo<Schema.toType<Schema.decodeTo<Schema.toType<Schema.NonEmptyString>, Schema.NonEmptyString, never, never>>, Schema.decodeTo<Schema.toType<Schema.NonEmptyString>, Schema.NonEmptyString, never, never>, never, never>;
+/**
+ * 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 declare const nonNegativeBigInt: <S extends Schema.Schema<bigint>>(schema: S) => Schema.decodeTo<Schema.toType<S>, S, never, never>;
+/**
+ * Extracts the "constructor input" type of a `Schema` — what `.make({...})`
+ * accepts.
+ *
+ * Differs from `S["Type"]` (the decoded type) in that fields carrying
+ * constructor defaults (e.g. an `Overrideable` timestamp) are *optional* in
+ * `MakeIn` but *required* in `Type`. Use it in signatures that accept a value to
+ * construct, so callers can pass a plain object literal without supplying the
+ * defaulted, override-branded fields.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ * import { SchemaX } from "@nunofyobiz/effect-extras"
+ *
+ * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
+ *
+ * const input: SchemaX.MakeIn<typeof Person> = { name: "Ada", age: 36 }
+ *
+ * assert.deepStrictEqual(input, { name: "Ada", age: 36 })
+ * ```
+ *
+ * @category models
+ * @since 0.0.0
+ */
+export type MakeIn<S extends {
+    readonly "~type.make.in": unknown;
+}> = S["~type.make.in"];
+/**
+ * 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 declare const pick: <const Fields extends Schema.Struct.Fields, const Keys extends readonly (keyof Fields & string)[]>(schema: Schema.Struct<Fields>, ...keys: Keys) => Schema.Struct<Pick<Fields, Keys[number]>>;
+/**
+ * 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 declare const omit: <const Fields extends Schema.Struct.Fields, const Keys extends readonly (keyof Fields & string)[]>(schema: Schema.Struct<Fields>, ...keys: Keys) => Schema.Struct<Omit<Fields, Keys[number]>>;
+/**
+ * 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 declare const partial: <Fields extends Schema.Struct.Fields>(schema: Schema.Struct<Fields>) => Schema.Struct<{ [K in keyof Fields]: Schema.optional<Fields[K]>; }>;
+/**
+ * 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 declare const pickPartial: <const Fields extends Schema.Struct.Fields, const Keys extends readonly (keyof Fields & string)[]>(schema: Schema.Struct<Fields>, ...keys: Keys) => Schema.Struct<{ [K in Keys[number]]: Schema.optional<Fields[K]>; }>;
+//# sourceMappingURL=SchemaX.d.ts.map

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"}