foldkit 0.104.1 → 0.105.0

package/dist/fieldValidation/fieldValidation.d.ts

@@ -0,0 +1,125 @@
+import { Array, Option, Schema as S } from 'effect';
+import { type Rule, type RuleMessage } from './rule.js';
+/** The `NotValidated` state: user hasn't interacted yet. */
+export type NotValidated<A> = Readonly<{
+    _tag: 'NotValidated';
+    value: A;
+}>;
+/** The `Validating` state: async validation is in flight. */
+export type Validating<A> = Readonly<{
+    _tag: 'Validating';
+    value: A;
+}>;
+/** The `Valid` state: every rule passed. */
+export type Valid<A> = Readonly<{
+    _tag: 'Valid';
+    value: A;
+}>;
+/** The `Invalid` state: one or more rules failed. Carries a non-empty `errors` array. */
+export type Invalid<A> = Readonly<{
+    _tag: 'Invalid';
+    value: A;
+    errors: Array.NonEmptyReadonlyArray<string>;
+}>;
+/** The four-state union that represents a field's value in the Model. */
+export type Field<A> = NotValidated<A> | Validating<A> | Valid<A> | Invalid<A>;
+/** Constructs a `NotValidated` state. */
+export declare const NotValidated: <A>(field: Readonly<{
+    value: A;
+}>) => NotValidated<A>;
+/** Constructs a `Validating` state. */
+export declare const Validating: <A>(field: Readonly<{
+    value: A;
+}>) => Validating<A>;
+/** Constructs a `Valid` state. */
+export declare const Valid: <A>(field: Readonly<{
+    value: A;
+}>) => Valid<A>;
+/** Constructs an `Invalid` state. */
+export declare const Invalid: <A>(field: Readonly<{
+    value: A;
+    errors: Array.NonEmptyReadonlyArray<string>;
+}>) => Invalid<A>;
+/** Builds the four-state `Field` Schema for a value of the given Schema. Put the
+ *  result in your Model. The value Schema should match what the control
+ *  actually holds as the user edits, not the type you parse it into:
+ *  `Field(S.String)` for text inputs, `Field(S.Array(S.String))` for a
+ *  multi-select. A scalar like a checkbox's boolean usually stays plain
+ *  `S.Boolean` in the Model; wrap it in `Field` only when it needs the
+ *  validation lifecycle. Validation rules stay separate, in a `makeRules`
+ *  bundle. */
+export declare const Field: <A, I>(valueSchema: S.Codec<A, I>) => S.Union<readonly [S.TaggedStruct<"NotValidated", {
+    readonly value: S.Codec<A, I, never, never>;
+}>, S.TaggedStruct<"Validating", {
+    readonly value: S.Codec<A, I, never, never>;
+}>, S.TaggedStruct<"Valid", {
+    readonly value: S.Codec<A, I, never, never>;
+}>, S.TaggedStruct<"Invalid", {
+    readonly value: S.Codec<A, I, never, never>;
+    readonly errors: S.NonEmptyArray<S.String>;
+}>]>;
+/** A field's validation rules: the required message (if any), the list of rules,
+ *  and an empty predicate. Produced by `makeRules`; consumed by the module's
+ *  operations (`validate`, `validateAll`, `isValid`, `isRequired`). The fields
+ *  are accessible but treating them as stable is discouraged. Prefer the
+ *  operations so internal shape changes don't break callers. */
+export type Rules<A> = Readonly<{
+    requiredMessage: Option.Option<RuleMessage<A>>;
+    rules: ReadonlyArray<Rule<A>>;
+    isEmpty: (value: A) => boolean;
+}>;
+/** Options accepted by `makeRules`. */
+export type MakeRulesOptions<A> = Readonly<{
+    /** When present, the field is required: empty values become `Invalid`
+     *  with the given message, and `isValid` requires `Valid`. Absent
+     *  means the field is optional: empty values stay `NotValidated`, and
+     *  `isValid` accepts `Valid` or `NotValidated`. */
+    required?: RuleMessage<A>;
+    rules?: ReadonlyArray<Rule<A>>;
+    /** Predicate for what counts as "empty" for this field. Defaults to empty
+     *  string and empty array; every other value is treated as present. Pass
+     *  `(value) => value.trim() === ''` to treat whitespace-only input as empty. */
+    isEmpty?: (value: A) => boolean;
+}>;
+/** Creates a `Rules` bundle from options. The value type defaults to `string`;
+ *  for other field values, annotate it: `makeRules<ReadonlyArray<Tag>>({ ... })`. */
+export declare const makeRules: <A = string>(options?: MakeRulesOptions<A>) => Rules<A>;
+/** Validates a new value and returns the next field state.
+ *
+ *  For required fields, an empty value produces `Invalid` with the
+ *  required message. For optional fields, an empty value produces
+ *  `NotValidated`. Non-empty values run through the field's rules;
+ *  the first failure becomes `Invalid`, otherwise the result is `Valid`. */
+export declare const validate: <A>(rules: Rules<A>) => (value: A) => Field<A>;
+/** Like `validate` but collects every failing rule into the
+ *  `Invalid` state's errors array instead of stopping at the first. */
+export declare const validateAll: <A>(rules: Rules<A>) => (value: A) => Field<A>;
+/** Returns true when the field's current state is acceptable given its
+ *  rules. For required fields, only `Valid` returns `true`. For optional
+ *  fields, `Valid` or `NotValidated` both return `true`. `Invalid` and
+ *  `Validating` always return `false`.
+ *
+ *  The name is distinct from the `Valid` tag on purpose: `isValid`
+ *  answers "is this state an acceptable result?", which for an optional
+ *  field is broader than `_tag === 'Valid'`. For pattern-matching on the
+ *  state itself, check the `_tag` directly. */
+export declare const isValid: <A>(rules: Rules<A>) => (state: Field<A>) => boolean;
+/** Returns true when the rules mark the field as required. Useful for
+ *  rendering affordances like a `*` next to required field labels. */
+export declare const isRequired: <A>(rules: Rules<A>) => boolean;
+/** Returns true when the state's tag is `Invalid`. Tag-only predicate;
+ *  unlike `!isValid(rules)(state)`, this does not treat `NotValidated`
+ *  or `Validating` as errors. Use for "has the user seen a rule failure
+ *  on this field?" affordances like red borders or per-step error
+ *  indicators. */
+export declare const isInvalid: (state: Field<unknown>) => boolean;
+/** Returns true when every field is acceptable per its rules, by `isValid`.
+ *  Each pair is a field's `[state, rules]`. The pairs in one call share a
+ *  value type, so a call gates fields of a single type; for a form that mixes
+ *  types, call `allValid` once per type and combine the results with `&&`.
+ *  Use for form-level submit gates. */
+export declare const allValid: <A>(pairs: ReadonlyArray<readonly [Field<A>, Rules<A>]>) => boolean;
+/** Returns true when any state in the input has tag `Invalid`. Use for
+ *  "this step/section has errors" affordances, independent of rules. */
+export declare const anyInvalid: (states: ReadonlyArray<Field<unknown>>) => boolean;
+//# sourceMappingURL=fieldValidation.d.ts.map

package/dist/fieldValidation/fieldValidation.d.ts.map

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

package/dist/fieldValidation/fieldValidation.js

@@ -0,0 +1,127 @@
+import { Array, Option, Result, Schema as S, String, pipe } from 'effect';
+import { resolveMessage } from './rule.js';
+/** Constructs a `NotValidated` state. */
+export const NotValidated = (field) => ({
+    _tag: 'NotValidated',
+    value: field.value,
+});
+/** Constructs a `Validating` state. */
+export const Validating = (field) => ({
+    _tag: 'Validating',
+    value: field.value,
+});
+/** Constructs a `Valid` state. */
+export const Valid = (field) => ({
+    _tag: 'Valid',
+    value: field.value,
+});
+/** Constructs an `Invalid` state. */
+export const Invalid = (field) => ({
+    _tag: 'Invalid',
+    value: field.value,
+    errors: field.errors,
+});
+/** Builds the four-state `Field` Schema for a value of the given Schema. Put the
+ *  result in your Model. The value Schema should match what the control
+ *  actually holds as the user edits, not the type you parse it into:
+ *  `Field(S.String)` for text inputs, `Field(S.Array(S.String))` for a
+ *  multi-select. A scalar like a checkbox's boolean usually stays plain
+ *  `S.Boolean` in the Model; wrap it in `Field` only when it needs the
+ *  validation lifecycle. Validation rules stay separate, in a `makeRules`
+ *  bundle. */
+export const Field = (valueSchema) => S.Union([
+    S.TaggedStruct('NotValidated', { value: valueSchema }),
+    S.TaggedStruct('Validating', { value: valueSchema }),
+    S.TaggedStruct('Valid', { value: valueSchema }),
+    S.TaggedStruct('Invalid', {
+        value: valueSchema,
+        errors: S.NonEmptyArray(S.String),
+    }),
+]);
+const isEmptyValue = (value) => {
+    if (typeof value === 'string') {
+        return String.isEmpty(value);
+    }
+    if (Array.isArray(value)) {
+        return Array.isReadonlyArrayEmpty(value);
+    }
+    return false;
+};
+/** Creates a `Rules` bundle from options. The value type defaults to `string`;
+ *  for other field values, annotate it: `makeRules<ReadonlyArray<Tag>>({ ... })`. */
+export const makeRules = (options = {}) => ({
+    requiredMessage: Option.fromNullishOr(options.required),
+    rules: options.rules ?? [],
+    isEmpty: options.isEmpty ?? isEmptyValue,
+});
+// OPERATIONS
+/** Validates a new value and returns the next field state.
+ *
+ *  For required fields, an empty value produces `Invalid` with the
+ *  required message. For optional fields, an empty value produces
+ *  `NotValidated`. Non-empty values run through the field's rules;
+ *  the first failure becomes `Invalid`, otherwise the result is `Valid`. */
+export const validate = (rules) => (value) => {
+    if (rules.isEmpty(value)) {
+        return Option.match(rules.requiredMessage, {
+            onNone: () => NotValidated({ value }),
+            onSome: message => Invalid({ value, errors: [resolveMessage(message, value)] }),
+        });
+    }
+    return pipe(rules.rules, Array.findFirst(([predicate]) => !predicate(value)), Option.match({
+        onNone: () => Valid({ value }),
+        onSome: ([, message]) => Invalid({ value, errors: [resolveMessage(message, value)] }),
+    }));
+};
+/** Like `validate` but collects every failing rule into the
+ *  `Invalid` state's errors array instead of stopping at the first. */
+export const validateAll = (rules) => (value) => {
+    if (rules.isEmpty(value)) {
+        return Option.match(rules.requiredMessage, {
+            onNone: () => NotValidated({ value }),
+            onSome: message => Invalid({ value, errors: [resolveMessage(message, value)] }),
+        });
+    }
+    return pipe(rules.rules, Array.filterMap(([predicate, message]) => !predicate(value)
+        ? Result.succeed(resolveMessage(message, value))
+        : Result.failVoid), Array.match({
+        onEmpty: () => Valid({ value }),
+        onNonEmpty: errors => Invalid({ value, errors }),
+    }));
+};
+/** Returns true when the field's current state is acceptable given its
+ *  rules. For required fields, only `Valid` returns `true`. For optional
+ *  fields, `Valid` or `NotValidated` both return `true`. `Invalid` and
+ *  `Validating` always return `false`.
+ *
+ *  The name is distinct from the `Valid` tag on purpose: `isValid`
+ *  answers "is this state an acceptable result?", which for an optional
+ *  field is broader than `_tag === 'Valid'`. For pattern-matching on the
+ *  state itself, check the `_tag` directly. */
+export const isValid = (rules) => (state) => {
+    if (state._tag === 'Invalid' || state._tag === 'Validating') {
+        return false;
+    }
+    if (Option.isSome(rules.requiredMessage)) {
+        return state._tag === 'Valid';
+    }
+    return true;
+};
+/** Returns true when the rules mark the field as required. Useful for
+ *  rendering affordances like a `*` next to required field labels. */
+export const isRequired = (rules) => Option.isSome(rules.requiredMessage);
+/** Returns true when the state's tag is `Invalid`. Tag-only predicate;
+ *  unlike `!isValid(rules)(state)`, this does not treat `NotValidated`
+ *  or `Validating` as errors. Use for "has the user seen a rule failure
+ *  on this field?" affordances like red borders or per-step error
+ *  indicators. */
+export const isInvalid = (state) => state._tag === 'Invalid';
+/** Returns true when every field is acceptable per its rules, by `isValid`.
+ *  Each pair is a field's `[state, rules]`. The pairs in one call share a
+ *  value type, so a call gates fields of a single type; for a form that mixes
+ *  types, call `allValid` once per type and combine the results with `&&`.
+ *  Use for form-level submit gates. */
+export const allValid = (pairs) => Array.every(pairs, ([state, rules]) => isValid(rules)(state));
+/** Returns true when any state in the input has tag `Invalid`. Use for
+ *  "this step/section has errors" affordances, independent of rules. */
+export const anyInvalid = (states) => Array.some(states, isInvalid);

package/dist/fieldValidation/index.d.ts

@@ -1,121 +1,3 @@
-import { Option, Predicate, Schema as S } from 'effect';
-/** An error message for a rule: either a static string, or a function that receives the invalid value. */
-export type RuleMessage = string | ((value: string) => string);
-/** A tuple of a predicate and error message used for field validation. */
-export type Rule = readonly [Predicate.Predicate<string>, RuleMessage];
-export declare const resolveMessage: (message: RuleMessage, value: string) => string;
-/** The `NotValidated` state: user hasn't interacted yet. */
-export declare const NotValidated: import("../schema/index.js").CallableTaggedStruct<"NotValidated", {
-    value: S.String;
-}>;
-/** The `Validating` state: async validation is in flight. */
-export declare const Validating: import("../schema/index.js").CallableTaggedStruct<"Validating", {
-    value: S.String;
-}>;
-/** The `Valid` state: every rule passed. */
-export declare const Valid: import("../schema/index.js").CallableTaggedStruct<"Valid", {
-    value: S.String;
-}>;
-/** The `Invalid` state: one or more rules failed. Carries a non-empty `errors` array. */
-export declare const Invalid: import("../schema/index.js").CallableTaggedStruct<"Invalid", {
-    value: S.String;
-    errors: S.NonEmptyArray<S.String>;
-}>;
-/** The four-state union that represents a field's value in the Model. */
-export declare const Field: S.Union<readonly [import("../schema/index.js").CallableTaggedStruct<"NotValidated", {
-    value: S.String;
-}>, import("../schema/index.js").CallableTaggedStruct<"Validating", {
-    value: S.String;
-}>, import("../schema/index.js").CallableTaggedStruct<"Valid", {
-    value: S.String;
-}>, import("../schema/index.js").CallableTaggedStruct<"Invalid", {
-    value: S.String;
-    errors: S.NonEmptyArray<S.String>;
-}>]>;
-export type Field = typeof Field.Type;
-/** A field's validation rules: the required message (if any), the list of rules,
- *  and an empty predicate. Produced by `makeRules`; consumed by the module's
- *  operations (`validate`, `validateAll`, `isValid`, `isRequired`, `allValid`).
- *  The fields are accessible but treating them as stable is discouraged.
- *  Prefer the operations so internal shape changes don't break callers. */
-export type Rules = Readonly<{
-    requiredMessage: Option.Option<RuleMessage>;
-    rules: ReadonlyArray<Rule>;
-    isEmpty: (value: string) => boolean;
-}>;
-/** Options accepted by `makeRules`. */
-export type MakeRulesOptions = Readonly<{
-    /** When present, the field is required: empty values become `Invalid`
-     *  with the given message, and `isValid` requires `Valid`. Absent
-     *  means the field is optional: empty values stay `NotValidated`, and
-     *  `isValid` accepts `Valid` or `NotValidated`. */
-    required?: RuleMessage;
-    rules?: ReadonlyArray<Rule>;
-    /** Predicate for what counts as "empty" for this field. Defaults to
-     *  `String.isEmpty` (the empty string only). Pass `(v) => v.trim() === ''`
-     *  to treat whitespace-only input as empty. */
-    isEmpty?: (value: string) => boolean;
-}>;
-export declare const makeRules: (options?: MakeRulesOptions) => Rules;
-/** Validates a new value and returns the next field state.
- *
- *  For required fields, an empty value produces `Invalid` with the
- *  required message. For optional fields, an empty value produces
- *  `NotValidated`. Non-empty values run through the field's rules;
- *  the first failure becomes `Invalid`, otherwise the result is `Valid`. */
-export declare const validate: (rules: Rules) => (value: string) => Field;
-/** Like `validate` but collects every failing rule into the
- *  `Invalid` state's errors array instead of stopping at the first. */
-export declare const validateAll: (rules: Rules) => (value: string) => Field;
-/** Returns true when the field's current state is acceptable given its
- *  rules. For required fields, only `Valid` returns `true`. For optional
- *  fields, `Valid` or `NotValidated` both return `true`. `Invalid` and
- *  `Validating` always return `false`.
- *
- *  The name is distinct from the `Valid` tag on purpose: `isValid`
- *  answers "is this state an acceptable result?", which for an optional
- *  field is broader than `_tag === 'Valid'`. For pattern-matching on the
- *  state itself, check the `_tag` directly. */
-export declare const isValid: (rules: Rules) => (state: Field) => boolean;
-/** Returns true when the rules mark the field as required. Useful for
- *  rendering affordances like a `*` next to required field labels. */
-export declare const isRequired: (rules: Rules) => boolean;
-/** Returns true when the state's tag is `Invalid`. Tag-only predicate;
- *  unlike `!isValid(rules)(state)`, this does not treat `NotValidated`
- *  or `Validating` as errors. Use for "has the user seen a rule failure
- *  on this field?" affordances like red borders or per-step error
- *  indicators. */
-export declare const isInvalid: (state: Field) => boolean;
-/** Returns true when every `(state, rules)` pair in the input is
- *  acceptable per `isValid`. Use for form-level submit gates. */
-export declare const allValid: (pairs: ReadonlyArray<readonly [Field, Rules]>) => boolean;
-/** Returns true when any state in the input has tag `Invalid`. Use for
- *  "this step/section has errors" affordances, independent of rules. */
-export declare const anyInvalid: (states: ReadonlyArray<Field>) => boolean;
-/** Creates a `Rule` that checks if a string meets a minimum length. */
-export declare const minLength: (min: number, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string does not exceed a maximum length. */
-export declare const maxLength: (max: number, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string matches a regular expression. */
-export declare const pattern: (regex: RegExp, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string is a valid email format. */
-export declare const email: (message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string is a valid URL format.
- *
- *  By default the URL must include an `http://` or `https://` protocol.
- *  Pass `{ requireProtocol: false }` to accept bare domains. */
-export declare const url: (options?: Readonly<{
-    message?: RuleMessage;
-    requireProtocol?: boolean;
-}>) => Rule;
-/** Creates a `Rule` that checks if a string begins with a specified prefix. */
-export declare const startsWith: (prefix: string, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string ends with a specified suffix. */
-export declare const endsWith: (suffix: string, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string contains a specified substring. */
-export declare const includes: (substring: string, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string exactly matches an expected value. */
-export declare const equals: (expected: string, message?: RuleMessage) => Rule;
-/** Creates a `Rule` that checks if a string is one of a specified set of allowed values. */
-export declare const oneOf: (values: ReadonlyArray<string>, message?: RuleMessage) => Rule;
+export * from './fieldValidation.js';
+export * as Rule from './rule.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/fieldValidation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fieldValidation/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fieldValidation/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AAEpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA"}

package/dist/fieldValidation/index.js

@@ -1,144 +1,2 @@
-import { Array, Number as Number_, Option, Result, Schema as S, String, flow, pipe, } from 'effect';
-import { ts } from '../schema/index.js';
-export const resolveMessage = (message, value) => typeof message === 'string' ? message : message(value);
-// STATE
-/** The `NotValidated` state: user hasn't interacted yet. */
-export const NotValidated = ts('NotValidated', { value: S.String });
-/** The `Validating` state: async validation is in flight. */
-export const Validating = ts('Validating', { value: S.String });
-/** The `Valid` state: every rule passed. */
-export const Valid = ts('Valid', { value: S.String });
-/** The `Invalid` state: one or more rules failed. Carries a non-empty `errors` array. */
-export const Invalid = ts('Invalid', {
-    value: S.String,
-    errors: S.NonEmptyArray(S.String),
-});
-/** The four-state union that represents a field's value in the Model. */
-export const Field = S.Union([NotValidated, Validating, Valid, Invalid]);
-export const makeRules = (options = {}) => ({
-    requiredMessage: Option.fromNullishOr(options.required),
-    rules: options.rules ?? [],
-    isEmpty: options.isEmpty ?? String.isEmpty,
-});
-// OPERATIONS
-/** Validates a new value and returns the next field state.
- *
- *  For required fields, an empty value produces `Invalid` with the
- *  required message. For optional fields, an empty value produces
- *  `NotValidated`. Non-empty values run through the field's rules;
- *  the first failure becomes `Invalid`, otherwise the result is `Valid`. */
-export const validate = (rules) => (value) => {
-    if (rules.isEmpty(value)) {
-        return Option.match(rules.requiredMessage, {
-            onNone: () => NotValidated({ value }),
-            onSome: message => Invalid({ value, errors: [resolveMessage(message, value)] }),
-        });
-    }
-    return pipe(rules.rules, Array.findFirst(([predicate]) => !predicate(value)), Option.match({
-        onNone: () => Valid({ value }),
-        onSome: ([, message]) => Invalid({ value, errors: [resolveMessage(message, value)] }),
-    }));
-};
-/** Like `validate` but collects every failing rule into the
- *  `Invalid` state's errors array instead of stopping at the first. */
-export const validateAll = (rules) => (value) => {
-    if (rules.isEmpty(value)) {
-        return Option.match(rules.requiredMessage, {
-            onNone: () => NotValidated({ value }),
-            onSome: message => Invalid({ value, errors: [resolveMessage(message, value)] }),
-        });
-    }
-    return pipe(rules.rules, Array.filterMap(([predicate, message]) => !predicate(value)
-        ? Result.succeed(resolveMessage(message, value))
-        : Result.failVoid), Array.match({
-        onEmpty: () => Valid({ value }),
-        onNonEmpty: errors => Invalid({ value, errors }),
-    }));
-};
-/** Returns true when the field's current state is acceptable given its
- *  rules. For required fields, only `Valid` returns `true`. For optional
- *  fields, `Valid` or `NotValidated` both return `true`. `Invalid` and
- *  `Validating` always return `false`.
- *
- *  The name is distinct from the `Valid` tag on purpose: `isValid`
- *  answers "is this state an acceptable result?", which for an optional
- *  field is broader than `_tag === 'Valid'`. For pattern-matching on the
- *  state itself, check the `_tag` directly. */
-export const isValid = (rules) => (state) => {
-    if (state._tag === 'Invalid' || state._tag === 'Validating') {
-        return false;
-    }
-    if (Option.isSome(rules.requiredMessage)) {
-        return state._tag === 'Valid';
-    }
-    return true;
-};
-/** Returns true when the rules mark the field as required. Useful for
- *  rendering affordances like a `*` next to required field labels. */
-export const isRequired = (rules) => Option.isSome(rules.requiredMessage);
-/** Returns true when the state's tag is `Invalid`. Tag-only predicate;
- *  unlike `!isValid(rules)(state)`, this does not treat `NotValidated`
- *  or `Validating` as errors. Use for "has the user seen a rule failure
- *  on this field?" affordances like red borders or per-step error
- *  indicators. */
-export const isInvalid = (state) => state._tag === 'Invalid';
-/** Returns true when every `(state, rules)` pair in the input is
- *  acceptable per `isValid`. Use for form-level submit gates. */
-export const allValid = (pairs) => Array.every(pairs, ([state, rules]) => isValid(rules)(state));
-/** Returns true when any state in the input has tag `Invalid`. Use for
- *  "this step/section has errors" affordances, independent of rules. */
-export const anyInvalid = (states) => Array.some(states, isInvalid);
-// STRING RULES
-/** Creates a `Rule` that checks if a string meets a minimum length. */
-export const minLength = (min, message) => [
-    flow(String.length, Number_.isGreaterThanOrEqualTo(min)),
-    message ?? `Must be at least ${min} characters`,
-];
-/** Creates a `Rule` that checks if a string does not exceed a maximum length. */
-export const maxLength = (max, message) => [
-    flow(String.length, Number_.isLessThanOrEqualTo(max)),
-    message ?? `Must be at most ${max} characters`,
-];
-/** Creates a `Rule` that checks if a string matches a regular expression. */
-export const pattern = (regex, message = 'Invalid format') => [flow(String.match(regex), Option.isSome), message];
-const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-/** Creates a `Rule` that checks if a string is a valid email format. */
-export const email = (message = 'Invalid email address') => pattern(EMAIL_REGEX, message);
-const STRICT_URL_REGEX = /^https?:\/\/.+/;
-const PERMISSIVE_URL_REGEX = /^(https?:\/\/)?\S+\.\S+$/;
-/** Creates a `Rule` that checks if a string is a valid URL format.
- *
- *  By default the URL must include an `http://` or `https://` protocol.
- *  Pass `{ requireProtocol: false }` to accept bare domains. */
-export const url = (options = {}) => {
-    const { message = 'Invalid URL', requireProtocol = true } = options;
-    return pattern(requireProtocol ? STRICT_URL_REGEX : PERMISSIVE_URL_REGEX, message);
-};
-/** Creates a `Rule` that checks if a string begins with a specified prefix. */
-export const startsWith = (prefix, message) => [
-    flow(String.startsWith(prefix)),
-    message ?? `Must start with ${prefix}`,
-];
-/** Creates a `Rule` that checks if a string ends with a specified suffix. */
-export const endsWith = (suffix, message) => [
-    flow(String.endsWith(suffix)),
-    message ?? `Must end with ${suffix}`,
-];
-/** Creates a `Rule` that checks if a string contains a specified substring. */
-export const includes = (substring, message) => [
-    flow(String.includes(substring)),
-    message ?? `Must contain ${substring}`,
-];
-/** Creates a `Rule` that checks if a string exactly matches an expected value. */
-export const equals = (expected, message) => [
-    value => value === expected,
-    message ?? `Must match ${expected}`,
-];
-/** Creates a `Rule` that checks if a string is one of a specified set of allowed values. */
-export const oneOf = (values, message) => {
-    const joinedValues = Array.join(values, ', ');
-    return [
-        value => Array.contains(values, value),
-        message ?? `Must be one of: ${joinedValues}`,
-    ];
-};
+export * from './fieldValidation.js';
+export * as Rule from './rule.js';

package/dist/fieldValidation/public.d.ts

@@ -1,3 +1,4 @@
-export { makeRules, validate, validateAll, isValid, isInvalid, isRequired, allValid, anyInvalid, resolveMessage, NotValidated, Validating, Valid, Invalid, Field, minLength, maxLength, pattern, email, url, startsWith, endsWith, includes, equals, oneOf, } from './index.js';
-export type { Rules, MakeRulesOptions, Rule, RuleMessage } from './index.js';
+export { makeRules, validate, validateAll, isValid, isInvalid, isRequired, allValid, anyInvalid, NotValidated, Validating, Valid, Invalid, Field, } from './index.js';
+export type { Rules, MakeRulesOptions } from './index.js';
+export * as Rule from './rule.js';
 //# sourceMappingURL=public.d.ts.map

package/dist/fieldValidation/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/fieldValidation/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,QAAQ,EACR,WAAW,EACX,OAAO,EACP,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,cAAc,EACd,YAAY,EACZ,UAAU,EACV,KAAK,EACL,OAAO,EACP,KAAK,EACL,SAAS,EACT,SAAS,EACT,OAAO,EACP,KAAK,EACL,GAAG,EACH,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,KAAK,GACN,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/fieldValidation/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,QAAQ,EACR,WAAW,EACX,OAAO,EACP,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,UAAU,EACV,KAAK,EACL,OAAO,EACP,KAAK,GACN,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAEzD,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA"}

package/dist/fieldValidation/public.js

@@ -1 +1,2 @@
-export { makeRules, validate, validateAll, isValid, isInvalid, isRequired, allValid, anyInvalid, resolveMessage, NotValidated, Validating, Valid, Invalid, Field, minLength, maxLength, pattern, email, url, startsWith, endsWith, includes, equals, oneOf, } from './index.js';
+export { makeRules, validate, validateAll, isValid, isInvalid, isRequired, allValid, anyInvalid, NotValidated, Validating, Valid, Invalid, Field, } from './index.js';
+export * as Rule from './rule.js';

package/dist/fieldValidation/rule.d.ts

@@ -0,0 +1,46 @@
+import { Predicate, Schema as S } from 'effect';
+/** An error message for a rule: either a static string, or a function that receives the invalid value. */
+export type RuleMessage<A> = string | ((value: A) => string);
+/** A tuple of a predicate and error message used for field validation. */
+export type Rule<A> = readonly [Predicate.Predicate<A>, RuleMessage<A>];
+/** Resolves a `RuleMessage` to a concrete string, applying it to the value when the message is a function. */
+export declare const resolveMessage: <A>(message: RuleMessage<A>, value: A) => string;
+/** Creates a `Rule` that checks if a string meets a minimum length. */
+export declare const minLength: (min: number, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string does not exceed a maximum length. */
+export declare const maxLength: (max: number, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string matches a regular expression. */
+export declare const pattern: (regex: RegExp, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string is a valid email format. */
+export declare const email: (message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string is a valid URL format.
+ *
+ *  By default the URL must include an `http://` or `https://` protocol.
+ *  Pass `{ requireProtocol: false }` to accept bare domains. */
+export declare const url: (options?: Readonly<{
+    message?: RuleMessage<string>;
+    requireProtocol?: boolean;
+}>) => Rule<string>;
+/** Creates a `Rule` that checks if a string begins with a specified prefix. */
+export declare const startsWith: (prefix: string, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string ends with a specified suffix. */
+export declare const endsWith: (suffix: string, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string contains a specified substring. */
+export declare const includes: (substring: string, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string exactly matches an expected value. */
+export declare const equals: (expected: string, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks if a string is one of a specified set of allowed values. */
+export declare const oneOf: (values: ReadonlyArray<string>, message?: RuleMessage<string>) => Rule<string>;
+/** Creates a `Rule` that checks an array holds at least `min` items. */
+export declare const minItems: (min: number, message?: RuleMessage<ReadonlyArray<unknown>>) => Rule<ReadonlyArray<unknown>>;
+/** Creates a `Rule` that checks an array holds at most `max` items. */
+export declare const maxItems: (max: number, message?: RuleMessage<ReadonlyArray<unknown>>) => Rule<ReadonlyArray<unknown>>;
+/** Creates a `Rule` that passes when the value decodes through `schema`.
+ *
+ *  Use it to reuse a Schema you already maintain (a domain codec, a refined or
+ *  branded type you decode to on submit) as a field rule, so the rule stays in
+ *  sync with the schema instead of duplicating its logic. It does nothing a
+ *  custom rule can't, so prefer the dedicated rules for plain checks. Decoding
+ *  is synchronous: the schema must decode without running an effect. */
+export declare const fromSchema: <A, I>(schema: S.Codec<A, I>, message: RuleMessage<I>) => Rule<I>;
+//# sourceMappingURL=rule.d.ts.map

package/dist/fieldValidation/rule.d.ts.map

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

package/dist/fieldValidation/rule.js

@@ -0,0 +1,77 @@
+import { Array, Number as Number_, Option, Schema as S, String, flow, } from 'effect';
+/** Resolves a `RuleMessage` to a concrete string, applying it to the value when the message is a function. */
+export const resolveMessage = (message, value) => typeof message === 'string' ? message : message(value);
+// STRING RULES
+/** Creates a `Rule` that checks if a string meets a minimum length. */
+export const minLength = (min, message) => [
+    flow(String.length, Number_.isGreaterThanOrEqualTo(min)),
+    message ?? `Must be at least ${min} characters`,
+];
+/** Creates a `Rule` that checks if a string does not exceed a maximum length. */
+export const maxLength = (max, message) => [
+    flow(String.length, Number_.isLessThanOrEqualTo(max)),
+    message ?? `Must be at most ${max} characters`,
+];
+/** Creates a `Rule` that checks if a string matches a regular expression. */
+export const pattern = (regex, message = 'Invalid format') => [flow(String.match(regex), Option.isSome), message];
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/** Creates a `Rule` that checks if a string is a valid email format. */
+export const email = (message = 'Invalid email address') => pattern(EMAIL_REGEX, message);
+const STRICT_URL_REGEX = /^https?:\/\/.+/;
+const PERMISSIVE_URL_REGEX = /^(https?:\/\/)?\S+\.\S+$/;
+/** Creates a `Rule` that checks if a string is a valid URL format.
+ *
+ *  By default the URL must include an `http://` or `https://` protocol.
+ *  Pass `{ requireProtocol: false }` to accept bare domains. */
+export const url = (options = {}) => {
+    const { message = 'Invalid URL', requireProtocol = true } = options;
+    return pattern(requireProtocol ? STRICT_URL_REGEX : PERMISSIVE_URL_REGEX, message);
+};
+/** Creates a `Rule` that checks if a string begins with a specified prefix. */
+export const startsWith = (prefix, message) => [
+    String.startsWith(prefix),
+    message ?? `Must start with ${prefix}`,
+];
+/** Creates a `Rule` that checks if a string ends with a specified suffix. */
+export const endsWith = (suffix, message) => [
+    String.endsWith(suffix),
+    message ?? `Must end with ${suffix}`,
+];
+/** Creates a `Rule` that checks if a string contains a specified substring. */
+export const includes = (substring, message) => [
+    String.includes(substring),
+    message ?? `Must contain ${substring}`,
+];
+/** Creates a `Rule` that checks if a string exactly matches an expected value. */
+export const equals = (expected, message) => [
+    value => value === expected,
+    message ?? `Must match ${expected}`,
+];
+/** Creates a `Rule` that checks if a string is one of a specified set of allowed values. */
+export const oneOf = (values, message) => {
+    const joinedValues = Array.join(values, ', ');
+    return [
+        value => Array.contains(values, value),
+        message ?? `Must be one of: ${joinedValues}`,
+    ];
+};
+// ARRAY RULES
+/** Creates a `Rule` that checks an array holds at least `min` items. */
+export const minItems = (min, message) => [
+    flow(Array.length, Number_.isGreaterThanOrEqualTo(min)),
+    message ?? `Must select at least ${min}`,
+];
+/** Creates a `Rule` that checks an array holds at most `max` items. */
+export const maxItems = (max, message) => [
+    flow(Array.length, Number_.isLessThanOrEqualTo(max)),
+    message ?? `Must select at most ${max}`,
+];
+// SCHEMA RULES
+/** Creates a `Rule` that passes when the value decodes through `schema`.
+ *
+ *  Use it to reuse a Schema you already maintain (a domain codec, a refined or
+ *  branded type you decode to on submit) as a field rule, so the rule stays in
+ *  sync with the schema instead of duplicating its logic. It does nothing a
+ *  custom rule can't, so prefer the dedicated rules for plain checks. Decoding
+ *  is synchronous: the schema must decode without running an effect. */
+export const fromSchema = (schema, message) => [flow(S.decodeOption(schema), Option.isSome), message];

package/dist/file/select.d.ts

@@ -1,8 +1,8 @@
-import { Effect } from 'effect';
+import { Effect, Option } from 'effect';
 import type { File } from './file.js';
 /**
  * Opens the native file picker allowing a single file to be selected. Resolves
- * with an array containing the selected file, or an empty array if the user
+ * with `Option.some(file)` if the user picked one, or `Option.none()` if they
  * cancelled. Mirrors Elm's `File.Select.file`.
  *
  * The `accept` argument is a list of MIME types or file extensions that
@@ -12,12 +12,17 @@ import type { File } from './file.js';
  * ```typescript
  * SelectResume(
  *   File.select(['application/pdf']).pipe(
- *     Effect.map(files => SelectedResume({ files })),
+ *     Effect.map(
+ *       Option.match({
+ *         onNone: () => CancelledSelectResume(),
+ *         onSome: file => SelectedResume({ file }),
+ *       }),
+ *     ),
  *   ),
  * )
  * ```
  */
-export declare const select: (accept: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<File>>;
+export declare const select: (accept: ReadonlyArray<string>) => Effect.Effect<Option.Option<File>>;
 /**
  * Opens the native file picker allowing multiple files to be selected at
  * once. Resolves with the array of selected files, or an empty array if the

package/dist/file/select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/file/select.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AA2CrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM,GACjB,QAAQ,aAAa,CAAC,MAAM,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAA4C,CAAA;AAEhF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,aAAa,CAAC,MAAM,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAA2C,CAAA"}
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/file/select.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AA2CrC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,GACjB,QAAQ,aAAa,CAAC,MAAM,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CACkC,CAAA;AAEtE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,aAAa,CAAC,MAAM,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAA2C,CAAA"}

package/dist/file/select.js

@@ -27,7 +27,7 @@ const openPicker = ({ accept, multiple, }) => Effect.callback((resume, signal) =
 });
 /**
  * Opens the native file picker allowing a single file to be selected. Resolves
- * with an array containing the selected file, or an empty array if the user
+ * with `Option.some(file)` if the user picked one, or `Option.none()` if they
  * cancelled. Mirrors Elm's `File.Select.file`.
  *
  * The `accept` argument is a list of MIME types or file extensions that
@@ -37,12 +37,17 @@ const openPicker = ({ accept, multiple, }) => Effect.callback((resume, signal) =
  * ```typescript
  * SelectResume(
  *   File.select(['application/pdf']).pipe(
- *     Effect.map(files => SelectedResume({ files })),
+ *     Effect.map(
+ *       Option.match({
+ *         onNone: () => CancelledSelectResume(),
+ *         onSome: file => SelectedResume({ file }),
+ *       }),
+ *     ),
  *   ),
  * )
  * ```
  */
-export const select = (accept) => openPicker({ accept, multiple: false });
+export const select = (accept) => openPicker({ accept, multiple: false }).pipe(Effect.map(Array.head));
 /**
  * Opens the native file picker allowing multiple files to be selected at
  * once. Resolves with the array of selected files, or an empty array if the

package/dist/test/apps/resumeUpload.d.ts

@@ -9,7 +9,7 @@ export declare const Model: S.Struct<{
 export type Model = typeof Model.Type;
 export declare const ClickedChooseResume: import("../../schema/index.js").CallableTaggedStruct<"ClickedChooseResume", {}>;
 export declare const SelectedResume: import("../../schema/index.js").CallableTaggedStruct<"SelectedResume", {
-    files: S.$Array<S.Schema<File>>;
+    file: S.Schema<File>;
 }>;
 export declare const CancelledSelectResume: import("../../schema/index.js").CallableTaggedStruct<"CancelledSelectResume", {}>;
 export declare const SucceededReadPreview: import("../../schema/index.js").CallableTaggedStruct<"SucceededReadPreview", {
@@ -18,7 +18,7 @@ export declare const SucceededReadPreview: import("../../schema/index.js").Calla
 export declare const FailedReadPreview: import("../../schema/index.js").CallableTaggedStruct<"FailedReadPreview", {}>;
 export declare const ClickedRemoveResume: import("../../schema/index.js").CallableTaggedStruct<"ClickedRemoveResume", {}>;
 export declare const Message: S.Union<readonly [import("../../schema/index.js").CallableTaggedStruct<"ClickedChooseResume", {}>, import("../../schema/index.js").CallableTaggedStruct<"SelectedResume", {
-    files: S.$Array<S.Schema<File>>;
+    file: S.Schema<File>;
 }>, import("../../schema/index.js").CallableTaggedStruct<"CancelledSelectResume", {}>, import("../../schema/index.js").CallableTaggedStruct<"SucceededReadPreview", {
     dataUrl: S.String;
 }>, import("../../schema/index.js").CallableTaggedStruct<"FailedReadPreview", {}>, import("../../schema/index.js").CallableTaggedStruct<"ClickedRemoveResume", {}>]>;
@@ -27,7 +27,7 @@ export declare const SelectResume: Command.CommandDefinitionNoArgs<"SelectResume
     readonly _tag: "CancelledSelectResume";
 } | {
     readonly _tag: "SelectedResume";
-    readonly files: readonly File[];
+    readonly file: File;
 }, never, never>>;
 export declare const ReadResumePreview: Command.CommandDefinitionWithArgs<"ReadResumePreview", {
     file: S.Schema<File>;

package/dist/test/apps/resumeUpload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resumeUpload.d.ts","sourceRoot":"","sources":["../../../src/test/apps/resumeUpload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAsB,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAEvE,OAAO,KAAK,OAAO,MAAM,wBAAwB,CAAA;AAEjD,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,qBAAqB,CAAA;AAMrD,eAAO,MAAM,KAAK;;;;EAIhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAIrC,eAAO,MAAM,mBAAmB,iFAA2B,CAAA;AAC3D,eAAO,MAAM,cAAc;;EAEzB,CAAA;AACF,eAAO,MAAM,qBAAqB,mFAA6B,CAAA;AAC/D,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AACF,eAAO,MAAM,iBAAiB,+EAAyB,CAAA;AACvD,eAAO,MAAM,mBAAmB,iFAA2B,CAAA;AAE3D,eAAO,MAAM,OAAO;;;;oKAOlB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,eAAO,MAAM,YAAY;;;;;iBAaxB,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;iBAU7B,CAAA;AAID,eAAO,MAAM,YAAY,EAAE,KAI1B,CAAA;AAID,KAAK,YAAY,GAAG,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;AAE7E,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,EAAE,SAAS,OAAO,KAAG,YAmCrD,CAAA;AAwBH,eAAO,MAAM,IAAI,GAAI,OAAO,KAAK,KAAG,IAqBnC,CAAA"}
+{"version":3,"file":"resumeUpload.d.ts","sourceRoot":"","sources":["../../../src/test/apps/resumeUpload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAsB,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAEhE,OAAO,KAAK,OAAO,MAAM,wBAAwB,CAAA;AAEjD,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,qBAAqB,CAAA;AAMrD,eAAO,MAAM,KAAK;;;;EAIhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAIrC,eAAO,MAAM,mBAAmB,iFAA2B,CAAA;AAC3D,eAAO,MAAM,cAAc;;EAEzB,CAAA;AACF,eAAO,MAAM,qBAAqB,mFAA6B,CAAA;AAC/D,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AACF,eAAO,MAAM,iBAAiB,+EAAyB,CAAA;AACvD,eAAO,MAAM,mBAAmB,iFAA2B,CAAA;AAE3D,eAAO,MAAM,OAAO;;;;oKAOlB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,eAAO,MAAM,YAAY;;;;;iBAaxB,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;iBAU7B,CAAA;AAID,eAAO,MAAM,YAAY,EAAE,KAI1B,CAAA;AAID,KAAK,YAAY,GAAG,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;AAE7E,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,EAAE,SAAS,OAAO,KAAG,YA+BrD,CAAA;AAwBH,eAAO,MAAM,IAAI,GAAI,OAAO,KAAK,KAAG,IAqBnC,CAAA"}

package/dist/test/apps/resumeUpload.js

@@ -1,4 +1,4 @@
-import { Array, Effect, Match as M, Option, Schema as S } from 'effect';
+import { Effect, Match as M, Option, Schema as S } from 'effect';
 import * as Command from '../../command/index.js';
 import * as File from '../../file/index.js';
 import { html } from '../../html/index.js';
@@ -13,7 +13,7 @@ export const Model = S.Struct({
 // MESSAGE
 export const ClickedChooseResume = m('ClickedChooseResume');
 export const SelectedResume = m('SelectedResume', {
-    files: S.Array(File.File),
+    file: File.File,
 });
 export const CancelledSelectResume = m('CancelledSelectResume');
 export const SucceededReadPreview = m('SucceededReadPreview', {
@@ -30,9 +30,9 @@ export const Message = S.Union([
     ClickedRemoveResume,
 ]);
 // COMMAND
-export const SelectResume = Command.define('SelectResume', SelectedResume, CancelledSelectResume)(File.select(['application/pdf']).pipe(Effect.map(Array.match({
-    onEmpty: () => CancelledSelectResume(),
-    onNonEmpty: files => SelectedResume({ files }),
+export const SelectResume = Command.define('SelectResume', SelectedResume, CancelledSelectResume)(File.select(['application/pdf']).pipe(Effect.map(Option.match({
+    onNone: () => CancelledSelectResume(),
+    onSome: file => SelectedResume({ file }),
 }))));
 export const ReadResumePreview = Command.define('ReadResumePreview', { file: File.File }, SucceededReadPreview, FailedReadPreview)(({ file }) => File.readAsDataUrl(file).pipe(Effect.map(dataUrl => SucceededReadPreview({ dataUrl })), Effect.catch(() => Effect.succeed(FailedReadPreview()))));
 // INIT
@@ -43,17 +43,14 @@ export const initialModel = {
 };
 export const update = (model, message) => M.value(message).pipe(M.withReturnType(), M.tagsExhaustive({
     ClickedChooseResume: () => [model, [SelectResume()]],
-    SelectedResume: ({ files }) => Option.match(Array.head(files), {
-        onNone: () => [model, []],
-        onSome: firstFile => [
-            evo(model, {
-                maybeResume: () => Option.some(firstFile),
-                maybePreviewDataUrl: () => Option.none(),
-                readStatus: () => 'Reading',
-            }),
-            [ReadResumePreview({ file: firstFile })],
-        ],
-    }),
+    SelectedResume: ({ file }) => [
+        evo(model, {
+            maybeResume: () => Option.some(file),
+            maybePreviewDataUrl: () => Option.none(),
+            readStatus: () => 'Reading',
+        }),
+        [ReadResumePreview({ file })],
+    ],
     CancelledSelectResume: () => [model, []],
     SucceededReadPreview: ({ dataUrl }) => [
         evo(model, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.104.1",
+  "version": "0.105.0",
   "description": "A TypeScript frontend framework, built on Effect and architected like Elm",
   "type": "module",
   "main": "./dist/index.js",
@@ -200,6 +200,7 @@
       "import": "./dist/devTools/public.js"
     }
   },
+  "sideEffects": false,
   "files": [
     "dist"
   ],