@playfast/forms 0.0.1

package/README.md

@@ -0,0 +1,125 @@
+# `@reform/forms`
+
+Headless form state for Reform. This package owns values, validation, field
+metadata, list operations, submit flow, and correlations with other Reform
+state. It renders nothing and has no DOM or React API.
+
+## Model
+
+Forms follow the same definition / implementation split as the rest of Reform:
+
+```ts
+import { Schema as S } from 'effect'
+import { Form } from '@reform/forms'
+import { CurrentUser, Settings } from './sources'
+
+const CheckoutValues = S.Struct({
+  email: S.String,
+  items: S.Array(S.Struct({ name: S.String, qty: S.Number })),
+  payment: S.Union(
+    S.TaggedStruct('Card', { cardNumber: S.String, cvv: S.String }),
+    S.TaggedStruct('Paypal', { email: S.String }),
+  ),
+})
+
+class CheckoutForm extends Form.make('CheckoutForm', {
+  schema: CheckoutValues,
+  inputs: { user: CurrentUser, settings: Settings },
+}) {}
+```
+
+`Form.make` creates a reflectable form definition. `Form.live` provides the
+runtime behavior:
+
+```ts
+const CheckoutFormLive = Form.live(CheckoutForm, {
+  initial: {
+    email: '',
+    items: [],
+    payment: { _tag: 'Card', cardNumber: '', cvv: '' },
+  },
+  limit: ({ inputs }) => ({
+    email: { required: true, disabled: !inputs.settings.emailEditable },
+    items: { minItems: 1, maxItems: inputs.settings.maxItems },
+  }),
+  validate: ({ values }) =>
+    values.email.includes('@')
+      ? undefined
+      : Form.error('email', 'Email must contain @'),
+  submit: ({ decoded, inputs }) => saveCheckout(decoded, inputs.user.id),
+})
+```
+
+The form is read inside compositions with `Form.view(CheckoutForm)`. The view is
+a typed, platform-neutral object:
+
+```ts
+const form = yield* Form.view(CheckoutForm)
+
+form.field('email').set('a@example.com')
+form.array('items').append({ name: 'Milk', qty: 1 })
+form.submit()
+```
+
+## Correlations
+
+`inputs` connects a form to other Reform state or calculations. Those inputs are
+read through the same tracking mechanism as normal composition reads, so a view
+that depends on the form also updates when form limitations or validation context
+change.
+
+Use this for permissions, calculated totals, feature flags, remote defaults, or
+cross-field constraints that come from outside the form values.
+
+## Limitations
+
+`limit` returns field metadata keyed by form path. The core does not interpret
+metadata as DOM attributes; it simply carries constraints to any renderer:
+
+```ts
+limit: ({ values }) => ({
+  email: { required: true, maxLength: 120 },
+  'payment.cardNumber': {
+    visible: values.payment._tag === 'Card',
+    meta: { mask: 'card' },
+  },
+})
+```
+
+Renderers and custom controls decide how to display these limitations.
+
+## Paths
+
+Path strings are type checked from the Effect Schema encoded value:
+
+- `field('email')`
+- `field('items[0].qty')`
+- `array('items')`
+- `variantValue('payment')`
+
+Invalid paths fail at compile time when used through the typed helpers.
+
+## Lists
+
+Array bindings expose stable keys and item operations:
+
+```ts
+const items = form.array('items')
+items.append({ name: '', qty: 1 })
+items.move(0, 1)
+items.remove(0)
+```
+
+Each item has `{ key, index, value, remove, move }`, so UI layers can map rows
+without owning form state.
+
+## Validation And Submit
+
+`submit()` first decodes the Effect Schema, then runs custom validation. Schema
+parse issues and custom errors both route into field errors. `canSubmit` is a
+derived read from the current decoded state and stored errors; it is advisory UI
+state, not a substitute for submit-time validation.
+
+`validate()` runs validation without attempting submit. `reset()` restores the
+initial values.
+

package/dist/cjs/form.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.view = exports.live = exports.make = exports.arrayKeysFor = exports.error = void 0;
+const effect_1 = require("effect");
+const reform_1 = require("reform");
+const path_js_1 = require("./path.js");
+const validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return validation_js_1.error; } });
+const unknownSchema = effect_1.Schema.Unknown;
+let nextArrayKey = 0;
+const makeArrayKey = () => `form-item-${nextArrayKey++}`;
+const arrayKeysFor = (value, path = '') => {
+    const out = {};
+    const visit = (current, currentPath) => {
+        if (Array.isArray(current)) {
+            out[currentPath] = current.map(() => makeArrayKey());
+            current.forEach((item, index) => visit(item, `${currentPath}[${index}]`));
+            return;
+        }
+        if (current !== null && typeof current === 'object') {
+            for (const [key, child] of Object.entries(current)) {
+                visit(child, currentPath.length === 0 ? key : `${currentPath}.${key}`);
+            }
+        }
+    };
+    visit(value, path);
+    return out;
+};
+exports.arrayKeysFor = arrayKeysFor;
+const initialState = (initial) => ({
+    values: initial,
+    initialValues: initial,
+    touched: {},
+    errors: {},
+    dirtyPaths: [],
+    submitCount: 0,
+    validationCount: 0,
+    lastSubmittedValues: effect_1.Option.none(),
+    arrayKeys: (0, exports.arrayKeysFor)(initial),
+});
+const markTouched = (touched, path) => ({ ...touched, [path]: true });
+const withValues = (state, values) => ({
+    ...state,
+    values,
+    dirtyPaths: (0, path_js_1.recalculateDirtyPaths)(state.initialValues, values),
+});
+const currentArray = (values, path) => {
+    const current = (0, path_js_1.getNestedValue)(values, path);
+    return Array.isArray(current) ? current : [];
+};
+const updateKeys = (state, path, f) => {
+    const existing = state.arrayKeys[path] ?? currentArray(state.values, path).map(() => makeArrayKey());
+    return { ...state.arrayKeys, [path]: f(existing) };
+};
+const setAtPath = (state, path, value) => withValues(state, (0, path_js_1.setNestedValue)(state.values, path, value));
+const appendAtPath = (state, path, value) => {
+    const items = currentArray(state.values, path);
+    const values = (0, path_js_1.setNestedValue)(state.values, path, [...items, value]);
+    return {
+        ...withValues(state, values),
+        arrayKeys: updateKeys(state, path, (keys) => [...keys, makeArrayKey()]),
+    };
+};
+const removeAtPath = (state, path, index) => {
+    const items = currentArray(state.values, path);
+    if (index < 0 || index >= items.length)
+        return state;
+    const values = (0, path_js_1.setNestedValue)(state.values, path, items.filter((_, i) => i !== index));
+    return {
+        ...withValues(state, values),
+        arrayKeys: updateKeys(state, path, (keys) => keys.filter((_, i) => i !== index)),
+    };
+};
+const moveAtPath = (state, path, from, to) => {
+    const items = currentArray(state.values, path);
+    const next = (0, path_js_1.moveAt)(items, from, to);
+    if (next === items)
+        return state;
+    const values = (0, path_js_1.setNestedValue)(state.values, path, next);
+    return {
+        ...withValues(state, values),
+        arrayKeys: updateKeys(state, path, (keys) => (0, path_js_1.moveAt)(keys, from, to)),
+    };
+};
+const swapAtPath = (state, path, a, b) => {
+    const items = currentArray(state.values, path);
+    if (a < 0 || b < 0 || a >= items.length || b >= items.length || a === b)
+        return state;
+    const swapped = (0, path_js_1.replaceAt)((0, path_js_1.replaceAt)(items, a, items[b]), b, items[a]);
+    const values = (0, path_js_1.setNestedValue)(state.values, path, swapped);
+    return {
+        ...withValues(state, values),
+        arrayKeys: updateKeys(state, path, (keys) => (0, path_js_1.replaceAt)((0, path_js_1.replaceAt)(keys, a, keys[b] ?? makeArrayKey()), b, keys[a] ?? makeArrayKey())),
+    };
+};
+const make = (name, config) => {
+    const state = reform_1.State.make(`${name}/state`, unknownSchema, {
+        title: `${name} form state`,
+    });
+    const events = {
+        set: reform_1.Event.make(`${name}/SetField`, effect_1.Schema.Struct({ path: effect_1.Schema.String, value: effect_1.Schema.Unknown })),
+        blur: reform_1.Event.make(`${name}/BlurField`, effect_1.Schema.Struct({ path: effect_1.Schema.String })),
+        reset: reform_1.Event.make(`${name}/Reset`, effect_1.Schema.Struct({})),
+        validationFinished: reform_1.Event.make(`${name}/ValidationFinished`, effect_1.Schema.Struct({
+            errors: effect_1.Schema.Record({ key: effect_1.Schema.String, value: effect_1.Schema.String }),
+        })),
+        submitAttempted: reform_1.Event.make(`${name}/SubmitAttempted`, effect_1.Schema.Struct({})),
+        submitSucceeded: reform_1.Event.make(`${name}/SubmitSucceeded`, effect_1.Schema.Struct({ values: effect_1.Schema.Unknown })),
+        append: reform_1.Event.make(`${name}/AppendItem`, effect_1.Schema.Struct({ path: effect_1.Schema.String, value: effect_1.Schema.Unknown })),
+        remove: reform_1.Event.make(`${name}/RemoveItem`, effect_1.Schema.Struct({ path: effect_1.Schema.String, index: effect_1.Schema.Number })),
+        move: reform_1.Event.make(`${name}/MoveItem`, effect_1.Schema.Struct({ path: effect_1.Schema.String, from: effect_1.Schema.Number, to: effect_1.Schema.Number })),
+        swap: reform_1.Event.make(`${name}/SwapItems`, effect_1.Schema.Struct({ path: effect_1.Schema.String, a: effect_1.Schema.Number, b: effect_1.Schema.Number })),
+    };
+    const reducer = reform_1.Reducer.make(`${name}/FormReducer`, {
+        states: [state],
+        events: Object.values(events),
+    });
+    const runtimeConfig = effect_1.Context.GenericTag(`reform/form/${name}/config`);
+    const inputs = (config.inputs ?? {});
+    return Object.assign(class {
+    }, {
+        manifest: {
+            kind: 'Form',
+            name,
+            schema: config.schema,
+            inputs,
+        },
+        state,
+        config: runtimeConfig,
+        events,
+        reducer,
+    });
+};
+exports.make = make;
+const live = (form, config) => {
+    const configTag = form.config;
+    const configLayer = effect_1.Layer.effect(configTag, effect_1.Effect.map(effect_1.Effect.context(), (context) => {
+        const runtimeConfig = {
+            initial: config.initial,
+            validate: (ctx) => {
+                const result = config.validate?.(ctx);
+                const effect = effect_1.Effect.isEffect(result) ? result : effect_1.Effect.succeed(result);
+                return effect_1.Effect.map(effect_1.Effect.provide(effect, context), (value) => (0, validation_js_1.normalizeErrors)(value));
+            },
+            submit: (ctx) => {
+                const result = config.submit?.(ctx);
+                const effect = effect_1.Effect.isEffect(result) ? result : effect_1.Effect.succeed(result);
+                return effect_1.Effect.asVoid(effect_1.Effect.provide(effect, context));
+            },
+        };
+        return config.limit === undefined
+            ? runtimeConfig
+            : { ...runtimeConfig, limit: config.limit };
+    }));
+    const reducerLayer = reform_1.Reducer.live(form.reducer, (state, event) => {
+        switch (event._tag) {
+            case form.events.set.tag:
+                return 'path' in event && 'value' in event ? setAtPath(state, event.path, event.value) : state;
+            case form.events.blur.tag:
+                return 'path' in event ? { ...state, touched: markTouched(state.touched, event.path) } : state;
+            case form.events.reset.tag:
+                return initialState(state.initialValues);
+            case form.events.validationFinished.tag:
+                return 'errors' in event ? { ...state, errors: event.errors, validationCount: state.validationCount + 1 } : state;
+            case form.events.submitAttempted.tag:
+                return { ...state, submitCount: state.submitCount + 1 };
+            case form.events.submitSucceeded.tag:
+                return 'values' in event ? { ...state, lastSubmittedValues: effect_1.Option.some(event.values) } : state;
+            case form.events.append.tag:
+                return 'path' in event && 'value' in event ? appendAtPath(state, event.path, event.value) : state;
+            case form.events.remove.tag:
+                return 'path' in event && 'index' in event ? removeAtPath(state, event.path, event.index) : state;
+            case form.events.move.tag:
+                return 'path' in event && 'from' in event && 'to' in event ? moveAtPath(state, event.path, event.from, event.to) : state;
+            case form.events.swap.tag:
+                return 'path' in event && 'a' in event && 'b' in event ? swapAtPath(state, event.path, event.a, event.b) : state;
+            default:
+                return state;
+        }
+    });
+    return effect_1.Layer.mergeAll(configLayer, reducerLayer).pipe(effect_1.Layer.provideMerge(reform_1.State.live(form.state, initialState(config.initial))));
+};
+exports.live = live;
+const readInput = (source) => effect_1.Effect.gen(function* () {
+    const store = yield* source.store;
+    const tracker = yield* effect_1.Effect.serviceOption(reform_1.CurrentTracker);
+    if (effect_1.Option.isSome(tracker))
+        tracker.value.add(store);
+    return store.getSnapshot();
+});
+const readInputs = (inputs) => effect_1.Effect.gen(function* () {
+    const out = {};
+    for (const source of Object.values(inputs)) {
+        out[source.name] = yield* readInput(source);
+    }
+    return out;
+});
+const limitationsFor = (limitations, path) => (limitations[path] ?? {});
+const trigger = (eventTrigger) => eventTrigger;
+const view = (form) => effect_1.Effect.gen(function* () {
+    const state = yield* form.state;
+    const runtimeConfig = yield* form.config;
+    // Erased boundary (same shape as the casts closing `live`/`readInputs`):
+    // under the `AnyForm` constraint `form.manifest.inputs` is the wildcard
+    // `any`, which would dissolve the generator's R to `unknown`; restate the
+    // call at the concrete `F`'s types so R keeps the declared input stores.
+    const inputs = (yield* readInputs(form.manifest.inputs));
+    const limitations = runtimeConfig.limit?.({ values: state.values, inputs }) ?? {};
+    const setField = yield* trigger(form.events.set.trigger);
+    const blurField = yield* trigger(form.events.blur.trigger);
+    const reset = yield* trigger(form.events.reset.trigger);
+    const append = yield* trigger(form.events.append.trigger);
+    const remove = yield* trigger(form.events.remove.trigger);
+    const move = yield* trigger(form.events.move.trigger);
+    const swap = yield* trigger(form.events.swap.trigger);
+    const runtime = yield* effect_1.Effect.runtime();
+    const schema = form.manifest.schema;
+    const decodeEither = effect_1.Schema.decodeUnknownEither(schema, { errors: 'all' })(state.values);
+    const canSubmit = effect_1.Either.isRight(decodeEither) && Object.keys(state.errors).length === 0;
+    const runValidation = (publishSubmitAttempt) => effect_1.Effect.gen(function* () {
+        if (publishSubmitAttempt)
+            yield* reform_1.Event.dispatch(form.events.submitAttempted, {});
+        const decoded = effect_1.Schema.decodeUnknownEither(schema, { errors: 'all' })(state.values);
+        if (effect_1.Either.isLeft(decoded)) {
+            yield* reform_1.Event.dispatch(form.events.validationFinished, { errors: (0, validation_js_1.routeParseError)(decoded.left) });
+            return effect_1.Option.none();
+        }
+        const custom = yield* runtimeConfig.validate({ values: state.values, decoded: decoded.right, inputs });
+        const errors = (0, validation_js_1.errorsToRecord)(custom);
+        yield* reform_1.Event.dispatch(form.events.validationFinished, { errors });
+        return Object.keys(errors).length === 0 ? effect_1.Option.some(decoded.right) : effect_1.Option.none();
+    });
+    const submit = () => {
+        effect_1.Runtime.runFork(runtime)(effect_1.Effect.gen(function* () {
+            const decoded = yield* runValidation(true);
+            if (effect_1.Option.isNone(decoded))
+                return;
+            yield* runtimeConfig.submit({ values: state.values, decoded: decoded.value, inputs });
+            yield* reform_1.Event.dispatch(form.events.submitSucceeded, { values: state.values });
+        }).pipe(effect_1.Effect.catchAllCause((cause) => effect_1.Effect.logError('reform form submit failed', cause))));
+    };
+    const validate = () => {
+        effect_1.Runtime.runFork(runtime)(runValidation(false));
+    };
+    const field = (path) => {
+        const value = (0, path_js_1.getNestedValue)(state.values, path);
+        return {
+            path,
+            value,
+            set: (next) => setField({
+                path,
+                value: typeof next === 'function' ? next(value) : next,
+            }),
+            blur: () => blurField({ path }),
+            error: (0, validation_js_1.firstError)(state.errors, path),
+            dirty: (0, path_js_1.isPathOrParentDirty)(state.dirtyPaths, path),
+            touched: state.touched[path] === true,
+            validating: false,
+            limitations: limitationsFor(limitations, path),
+        };
+    };
+    const array = (path) => {
+        const values = currentArray(state.values, path);
+        const keys = state.arrayKeys[path] ?? values.map((_, i) => `${path}-${i}`);
+        return {
+            path,
+            items: values.map((value, index) => ({
+                value,
+                index,
+                key: keys[index] ?? `${path}-${index}`,
+                remove: () => remove({ path, index }),
+                move: (to) => move({ path, from: index, to }),
+            })),
+            append: (value) => append({ path, value }),
+            remove: (index) => remove({ path, index }),
+            move: (from, to) => move({ path, from, to }),
+            swap: (a, b) => swap({ path, a, b }),
+            limitations: limitationsFor(limitations, path),
+        };
+    };
+    return {
+        values: state.values,
+        inputs,
+        errors: state.errors,
+        dirty: state.dirtyPaths.length > 0,
+        canSubmit,
+        submitCount: state.submitCount,
+        validationCount: state.validationCount,
+        lastSubmittedValues: state.lastSubmittedValues,
+        submit,
+        reset: () => reset({}),
+        validate,
+        field,
+        array,
+        variantValue: (path) => (0, path_js_1.getNestedValue)(state.values, path),
+    };
+});
+exports.view = view;

package/dist/cjs/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeParseError = exports.normalizeErrors = exports.firstError = exports.errorsToRecord = exports.setNestedValue = exports.schemaPathToFieldPath = exports.recalculateDirtyPaths = exports.moveAt = exports.joinPath = exports.isPathOrParentDirty = exports.getNestedValue = exports.view = exports.make = exports.live = exports.error = exports.unsafeArrayKeysFor = exports.Form = void 0;
+exports.Form = __importStar(require("./form.js"));
+var form_js_1 = require("./form.js");
+Object.defineProperty(exports, "unsafeArrayKeysFor", { enumerable: true, get: function () { return form_js_1.arrayKeysFor; } });
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return form_js_1.error; } });
+Object.defineProperty(exports, "live", { enumerable: true, get: function () { return form_js_1.live; } });
+Object.defineProperty(exports, "make", { enumerable: true, get: function () { return form_js_1.make; } });
+Object.defineProperty(exports, "view", { enumerable: true, get: function () { return form_js_1.view; } });
+var path_js_1 = require("./path.js");
+Object.defineProperty(exports, "getNestedValue", { enumerable: true, get: function () { return path_js_1.getNestedValue; } });
+Object.defineProperty(exports, "isPathOrParentDirty", { enumerable: true, get: function () { return path_js_1.isPathOrParentDirty; } });
+Object.defineProperty(exports, "joinPath", { enumerable: true, get: function () { return path_js_1.joinPath; } });
+Object.defineProperty(exports, "moveAt", { enumerable: true, get: function () { return path_js_1.moveAt; } });
+Object.defineProperty(exports, "recalculateDirtyPaths", { enumerable: true, get: function () { return path_js_1.recalculateDirtyPaths; } });
+Object.defineProperty(exports, "schemaPathToFieldPath", { enumerable: true, get: function () { return path_js_1.schemaPathToFieldPath; } });
+Object.defineProperty(exports, "setNestedValue", { enumerable: true, get: function () { return path_js_1.setNestedValue; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "errorsToRecord", { enumerable: true, get: function () { return validation_js_1.errorsToRecord; } });
+Object.defineProperty(exports, "firstError", { enumerable: true, get: function () { return validation_js_1.firstError; } });
+Object.defineProperty(exports, "normalizeErrors", { enumerable: true, get: function () { return validation_js_1.normalizeErrors; } });
+Object.defineProperty(exports, "routeParseError", { enumerable: true, get: function () { return validation_js_1.routeParseError; } });

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "sideEffects": []
+}

package/dist/cjs/path.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveAt = exports.replaceAt = exports.recalculateDirtyPaths = exports.setNestedValue = exports.getNestedValue = exports.isPathOrParentDirty = exports.isPathUnderRoot = exports.joinPath = exports.schemaPathToFieldPath = void 0;
+const effect_1 = require("effect");
+const BRACKET_NOTATION_REGEX = /\[(\d+)\]/g;
+const schemaPathToFieldPath = (path) => {
+    if (path.length === 0)
+        return '';
+    let result = String(path[0]);
+    for (let i = 1; i < path.length; i++) {
+        const segment = path[i];
+        result += typeof segment === 'number' ? `[${segment}]` : `.${String(segment)}`;
+    }
+    return result;
+};
+exports.schemaPathToFieldPath = schemaPathToFieldPath;
+const joinPath = (prefix, path) => prefix.length === 0 ? path : path.length === 0 ? prefix : `${prefix}.${path}`;
+exports.joinPath = joinPath;
+const isPathUnderRoot = (path, rootPath) => path === rootPath || path.startsWith(`${rootPath}.`) || path.startsWith(`${rootPath}[`);
+exports.isPathUnderRoot = isPathUnderRoot;
+const isPathOrParentDirty = (dirtyPaths, path) => {
+    if (dirtyPaths.includes(path))
+        return true;
+    let parent = path;
+    while (true) {
+        const lastDot = parent.lastIndexOf('.');
+        const lastBracket = parent.lastIndexOf('[');
+        const splitIndex = Math.max(lastDot, lastBracket);
+        if (splitIndex === -1)
+            return false;
+        parent = parent.substring(0, splitIndex);
+        if (dirtyPaths.includes(parent))
+            return true;
+    }
+};
+exports.isPathOrParentDirty = isPathOrParentDirty;
+const pathParts = (path) => path === '' ? [] : path.replace(BRACKET_NOTATION_REGEX, '.$1').split('.');
+const getNestedValue = (obj, path) => {
+    const parts = pathParts(path);
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+};
+exports.getNestedValue = getNestedValue;
+const setNestedValue = (obj, path, value) => {
+    const parts = pathParts(path);
+    if (parts.length === 0)
+        return value;
+    const result = Array.isArray(obj) ? [...obj] : { ...obj };
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (part === undefined)
+            return result;
+        const next = current[part];
+        current[part] = Array.isArray(next) ? [...next] : { ...next };
+        current = current[part];
+    }
+    const last = parts[parts.length - 1];
+    if (last !== undefined)
+        current[last] = value;
+    return result;
+};
+exports.setNestedValue = setNestedValue;
+const recalculateDirtyPaths = (initial, values, rootPath = '') => {
+    const dirty = new Set();
+    const visit = (current, original, path) => {
+        if (effect_1.Equal.equals(current, original))
+            return;
+        if (Array.isArray(current) || Array.isArray(original)) {
+            const currentItems = Array.isArray(current) ? current : [];
+            const originalItems = Array.isArray(original) ? original : [];
+            if (currentItems.length !== originalItems.length && path.length > 0)
+                dirty.add(path);
+            const length = Math.max(currentItems.length, originalItems.length);
+            for (let i = 0; i < length; i++) {
+                visit(currentItems[i], originalItems[i], path.length === 0 ? `[${i}]` : `${path}[${i}]`);
+            }
+            return;
+        }
+        if (current !== null &&
+            original !== null &&
+            typeof current === 'object' &&
+            typeof original === 'object') {
+            const currentRecord = current;
+            const originalRecord = original;
+            const keys = new Set([...Object.keys(currentRecord), ...Object.keys(originalRecord)]);
+            for (const key of keys) {
+                visit(currentRecord[key], originalRecord[key], path.length === 0 ? key : `${path}.${key}`);
+            }
+            return;
+        }
+        if (path.length > 0)
+            dirty.add(path);
+    };
+    visit(rootPath.length === 0 ? values : (0, exports.getNestedValue)(values, rootPath), rootPath.length === 0 ? initial : (0, exports.getNestedValue)(initial, rootPath), rootPath);
+    return Array.from(dirty).sort();
+};
+exports.recalculateDirtyPaths = recalculateDirtyPaths;
+const replaceAt = (values, index, value) => values.map((item, i) => (i === index ? value : item));
+exports.replaceAt = replaceAt;
+const moveAt = (values, from, to) => {
+    if (from < 0 || from >= values.length || to < 0 || to > values.length || from === to)
+        return values;
+    const next = [...values];
+    const item = next.splice(from, 1)[0];
+    if (item !== undefined)
+        next.splice(to, 0, item);
+    return next;
+};
+exports.moveAt = moveAt;

package/dist/cjs/validation.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstError = exports.routeParseError = exports.errorsToRecord = exports.normalizeErrors = exports.error = void 0;
+const effect_1 = require("effect");
+const path_js_1 = require("./path.js");
+const error = (path, message) => ({ path, message });
+exports.error = error;
+const normalizeErrors = (value) => {
+    if (value === undefined)
+        return [];
+    if (Array.isArray(value))
+        return value;
+    return [value];
+};
+exports.normalizeErrors = normalizeErrors;
+const errorsToRecord = (errors) => {
+    const out = {};
+    for (const entry of errors) {
+        if (out[entry.path] === undefined)
+            out[entry.path] = entry.message;
+    }
+    return out;
+};
+exports.errorsToRecord = errorsToRecord;
+const routeParseError = (parseError) => {
+    const formatted = effect_1.ParseResult.ArrayFormatter.formatErrorSync(parseError);
+    const out = {};
+    for (const issue of formatted) {
+        const path = (0, path_js_1.schemaPathToFieldPath)(issue.path);
+        if (out[path] === undefined)
+            out[path] = issue.message;
+    }
+    return out;
+};
+exports.routeParseError = routeParseError;
+const firstError = (errors, path) => {
+    const message = errors[path];
+    return message === undefined ? effect_1.Option.none() : effect_1.Option.some(message);
+};
+exports.firstError = firstError;