effect-atom-svelte 0.2.0 → 0.4.0

package/dist/internal/form/constraints.js

@@ -0,0 +1,166 @@
+import { SchemaAST } from "effect";
+const isJsonArray = (json) => Array.isArray(json);
+const objectPayload = (payload) => typeof payload === "object" && payload !== null && !isJsonArray(payload)
+    ? payload
+    : undefined;
+const finite = (payload, key) => {
+    const value = payload?.[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+};
+// An HTML pattern is compiled with the v flag and must match the whole value, while a Schema
+// pattern matches anywhere in it: only one anchored at both ends, with no flags but u or v, means
+// the same to both.
+const sameAsHtmlPattern = (source, flags) => {
+    if (flags !== undefined &&
+        !(typeof flags === "string" && ["", "u", "v"].includes(flags))) {
+        return false;
+    }
+    if (!(source.startsWith("^") && source.endsWith("$"))) {
+        return false;
+    }
+    // `^a|b$` is anchored only at its ends: the browser wraps it as `^(?:^a|b$)$`.
+    return !source.includes("|") && !source.endsWith("\\$");
+};
+// Effect's built-in checks say what they are in a `representation` annotation (`Schema.ts`, for
+// example `isMinLength`). Only the ones that map exactly onto an HTML attribute are read; exclusive
+// bounds and custom filters are left out.
+const readers = {
+    "effect/schema/isBetween": (payload) => ({
+        max: payload?.exclusiveMaximum === true
+            ? undefined
+            : finite(payload, "maximum"),
+        min: payload?.exclusiveMinimum === true
+            ? undefined
+            : finite(payload, "minimum"),
+    }),
+    "effect/schema/isBetweenLength": (payload) => ({
+        maxlength: finite(payload, "maximum"),
+        minlength: finite(payload, "minimum"),
+    }),
+    "effect/schema/isGreaterThanOrEqualTo": (payload) => ({
+        min: finite(payload, "minimum"),
+    }),
+    "effect/schema/isLessThanOrEqualTo": (payload) => ({
+        max: finite(payload, "maximum"),
+    }),
+    "effect/schema/isMaxLength": (payload) => ({
+        maxlength: finite(payload, "maxLength"),
+    }),
+    "effect/schema/isMinLength": (payload) => ({
+        minlength: finite(payload, "minLength"),
+    }),
+    "effect/schema/isPattern": (payload) => {
+        const source = payload?.source;
+        return typeof source === "string" &&
+            sameAsHtmlPattern(source, payload?.flags)
+            ? { pattern: source }
+            : {};
+    },
+};
+/** Copies `from`'s defined constraints into `into`, in `from`'s order. */
+const merge = (into, from) => {
+    Object.assign(into, Object.fromEntries(Object.entries(from).filter(([, value]) => value !== undefined)));
+};
+const readCheck = (check, into) => {
+    if (check._tag === "FilterGroup") {
+        for (const inner of check.checks) {
+            readCheck(inner, into);
+        }
+        return;
+    }
+    const representation = check.annotations?.representation;
+    if (representation === undefined) {
+        return;
+    }
+    const reader = readers[representation.id];
+    if (reader !== undefined) {
+        merge(into, reader(objectPayload(representation.payload)));
+    }
+};
+// The node's checks, then the checks along its encoding chain (NumberFromString keeps a range check
+// on the decoded Number and a NonEmpty check on the encoded String).
+const readNode = (ast, into) => {
+    for (const check of ast.checks ?? []) {
+        readCheck(check, into);
+    }
+    for (const link of ast.encoding ?? []) {
+        readNode(link.to, into);
+    }
+};
+// Steps into declarations (a Schema.Class wraps its Struct) and suspensions, to a node with fields.
+const unwrap = (ast) => {
+    if (SchemaAST.isSuspend(ast)) {
+        return unwrap(ast.thunk());
+    }
+    if (SchemaAST.isDeclaration(ast)) {
+        const [inner] = ast.typeParameters;
+        if (inner !== undefined) {
+            return unwrap(inner);
+        }
+        const last = ast.encoding?.at(-1)?.to;
+        return last === undefined ? ast : unwrap(last);
+    }
+    return ast;
+};
+// The field at one step below `ast`, with whether its key is optional. In a union, the first member
+// that has the step.
+const step = (ast, segment) => {
+    const node = unwrap(ast);
+    if (SchemaAST.isUnion(node)) {
+        for (const member of node.types) {
+            const found = step(member, segment);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    if (SchemaAST.isObjects(node) && typeof segment === "string") {
+        const property = node.propertySignatures.find((candidate) => candidate.name === segment);
+        return property === undefined
+            ? undefined
+            : { ast: property.type, optional: SchemaAST.isOptional(property.type) };
+    }
+    if (SchemaAST.isArrays(node) && typeof segment === "number") {
+        const element = node.elements[segment] ?? node.rest[0];
+        return element === undefined
+            ? undefined
+            : { ast: element, optional: SchemaAST.isOptional(element) };
+    }
+    return undefined;
+};
+// `optional(X)` is an optional key holding `X | undefined`; the constraints are X's.
+const withoutUndefined = (ast) => {
+    if (!SchemaAST.isUnion(ast)) {
+        return ast;
+    }
+    const types = ast.types.filter((member) => member._tag !== "Undefined");
+    return types.length === 1 && types[0] !== undefined ? types[0] : ast;
+};
+/** The HTML constraints for the field at `path` in `schema`'s AST. */
+export const constraintsAt = (root, path) => {
+    let found = {
+        ast: root,
+        optional: false,
+    };
+    for (const segment of path) {
+        found &&= step(found.ast, segment);
+    }
+    if (found === undefined) {
+        return {};
+    }
+    const { ast, optional } = found;
+    const into = {};
+    readNode(withoutUndefined(ast), into);
+    // `required` means "not empty" to a browser, so it is set only where the Schema rejects an empty
+    // string: a required key alone allows "", and a checkbox's boolean is always present.
+    const { minlength } = into;
+    const out = {};
+    if (!optional && typeof minlength === "number" && minlength >= 1) {
+        out.required = true;
+    }
+    merge(out, into);
+    return out;
+};

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;
+}