effect-atom-svelte 0.3.0 → 0.4.0

package/dist/internal/form/engine.d.ts

@@ -0,0 +1,56 @@
+import { Exit } from "effect";
+import { Atom } from "effect/reactivity";
+import type { AtomRegistry } from "effect/reactivity";
+import { ArrayImpl } from "./array.ts";
+import type { Constraints } from "./constraints.ts";
+import { FieldImpl } from "./field.ts";
+import { GroupImpl } from "./group.ts";
+import { InstanceImpl } from "./instance.ts";
+import type { IndexPath, KeyPath } from "./paths.ts";
+import type { Definition, EngineOptions, ErrorsInput, State } from "./types.ts";
+export declare class Engine {
+    #private;
+    readonly definition: Definition;
+    readonly options: EngineOptions;
+    readonly registry: AtomRegistry.AtomRegistry;
+    readonly stateAtom: Atom.Writable<State>;
+    readonly valuesAtom: Atom.Writable<unknown>;
+    readonly root: InstanceImpl;
+    constructor(definition: Definition, options: EngineOptions);
+    /** Reads state and values through these instead, as `useForm` does to make them reactive. */
+    setReaders(state: () => State, values: () => unknown): void;
+    get state(): State;
+    get values(): unknown;
+    /** Writes a field's value, as typing into it does. */
+    setField(path: KeyPath, value: unknown): void;
+    /** Marks a field touched, as leaving it does, and checks it if `validateOn` says so. */
+    leave(path: KeyPath): void;
+    setTouched(path: KeyPath, touched: boolean): void;
+    setValues(values: unknown): void;
+    /** Changes an array and its item keys together, so state stays with each item. */
+    updateArray(path: KeyPath, f: (items: unknown[], keys: number[]) => void): void;
+    newKey(): number;
+    /** The current initial values change: a clean form takes them, a dirty one keeps its edits. */
+    setInitial(initial: unknown): void;
+    reset(values?: unknown): void;
+    revertToLastSubmit(): void;
+    setErrors(errors: ErrorsInput, source: "submit" | "manual"): void;
+    /**
+     * Checks the given paths (all by default), shows their errors, and says whether they passed: no
+     * Schema error and no external error at or under any of them.
+     */
+    validate(paths?: readonly (string | IndexPath)[]): Promise<boolean>;
+    submit(args?: unknown): Promise<Exit.Exit<unknown, unknown>>;
+    /** The error to show on a path: from outside the Schema first, then the Schema's once revealed. */
+    errorAt(path: KeyPath): string | undefined;
+    indexPath(path: KeyPath): IndexPath | undefined;
+    /** Resolves `relative`, an index path below `base`, to a key path. */
+    resolve(base: KeyPath, relative: string | IndexPath): KeyPath;
+    elementId(path: KeyPath): string;
+    constraints(path: IndexPath): Constraints;
+    field(path: KeyPath): FieldImpl;
+    group(path: KeyPath): GroupImpl;
+    array(path: KeyPath): ArrayImpl;
+    /** Releases the instance's atoms; a submit in flight keeps them until it settles. */
+    dispose(): void;
+}