effect-atom-svelte 0.4.0 → 0.4.1

package/dist/Form.d.ts

@@ -92,7 +92,11 @@ export interface MakeOptions {
     readonly revalidateOn?: Timing | undefined;
     /** How long to wait after a change before validating. Defaults to none. */
     readonly debounce?: Duration.Input | undefined;
-    /** A message for an issue that has no `message` annotation, or `undefined` for Effect's own. */
+    /**
+     * A message for an issue that has no `message` annotation, or `undefined` for Effect's own. A
+     * value outside a union, such as one that isn't in a `Schema.Literals`, comes as an
+     * `InvalidType` whose `ast` is the union.
+     */
     readonly leafHook?: ((issue: SchemaIssue.Leaf) => string | undefined) | undefined;
     /** A message for a failed check that has no `message` annotation, or `undefined` for Effect's. */
     readonly checkHook?: ((issue: SchemaIssue.Filter) => string | undefined) | undefined;

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

@@ -9,5 +9,8 @@ export interface Constraints {
     readonly max?: number | undefined;
     readonly pattern?: string | undefined;
 }
-/** The HTML constraints for the field at `path` in `schema`'s AST. */
-export declare const constraintsAt: (root: SchemaAST.AST, path: IndexPath) => Constraints;
+/**
+ * The HTML constraints for the field at `path` in `schema`'s AST. `lengthAt` gives the length of the
+ * array at a path, read only for a tuple with elements after its rest.
+ */
+export declare const constraintsAt: (root: SchemaAST.AST, path: IndexPath, lengthAt: (path: IndexPath) => number | undefined) => Constraints;

package/dist/internal/form/constraints.js

@@ -104,13 +104,31 @@ const unwrap = (ast) => {
     }
     return ast;
 };
+// The element at `index`, picked as Effect's parser picks it (`Arrays.getParser` in `SchemaAST.ts`):
+// a fixed element, else the rest element, except that the elements after the rest are counted back
+// from the array's end. Those need its length; without one, there is no element.
+const elementAt = (node, index, length) => {
+    if (index < node.elements.length) {
+        return node.elements[index];
+    }
+    const [rest, ...tail] = node.rest;
+    if (tail.length === 0) {
+        return rest;
+    }
+    const len = length();
+    if (len === undefined) {
+        return undefined;
+    }
+    const threshold = Math.max(node.elements.length, len - tail.length);
+    return index >= threshold ? tail[index - threshold] : rest;
+};
 // 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 step = (ast, segment, length) => {
     const node = unwrap(ast);
     if (SchemaAST.isUnion(node)) {
         for (const member of node.types) {
-            const found = step(member, segment);
+            const found = step(member, segment, length);
             if (found !== undefined) {
                 return found;
             }
@@ -124,7 +142,7 @@ const step = (ast, segment) => {
             : { ast: property.type, optional: SchemaAST.isOptional(property.type) };
     }
     if (SchemaAST.isArrays(node) && typeof segment === "number") {
-        const element = node.elements[segment] ?? node.rest[0];
+        const element = elementAt(node, segment, length);
         return element === undefined
             ? undefined
             : { ast: element, optional: SchemaAST.isOptional(element) };
@@ -139,19 +157,13 @@ const withoutUndefined = (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;
+// A field's constraints depend only on its node and whether its key is optional, so each is read once.
+const cache = {
+    optional: new WeakMap(),
+    required: new WeakMap(),
+};
+const none = {};
+const read = (ast, optional) => {
     const into = {};
     readNode(withoutUndefined(ast), into);
     // `required` means "not empty" to a browser, so it is set only where the Schema rejects an empty
@@ -164,3 +176,27 @@ export const constraintsAt = (root, path) => {
     merge(out, into);
     return out;
 };
+/**
+ * The HTML constraints for the field at `path` in `schema`'s AST. `lengthAt` gives the length of the
+ * array at a path, read only for a tuple with elements after its rest.
+ */
+export const constraintsAt = (root, path, lengthAt) => {
+    let found = {
+        ast: root,
+        optional: false,
+    };
+    for (const [depth, segment] of path.entries()) {
+        found &&= step(found.ast, segment, () => lengthAt(path.slice(0, depth)));
+    }
+    if (found === undefined) {
+        return none;
+    }
+    const { ast, optional } = found;
+    const byNode = optional ? cache.optional : cache.required;
+    let constraints = byNode.get(ast);
+    if (constraints === undefined) {
+        constraints = read(ast, optional);
+        byNode.set(ast, constraints);
+    }
+    return constraints;
+};

package/dist/internal/form/engine.js

@@ -89,7 +89,6 @@ export class Engine {
     #fields = new Map();
     #groups = new Map();
     #arrays = new Map();
-    #constraints = new Map();
     constructor(definition, options) {
         this.definition = definition;
         this.options = options;
@@ -784,14 +783,11 @@ export class Engine {
             : `${this.options.id}-${idSuffix(path)}`;
     }
     constraints(path) {
-        const schemaPath = path.map((segment) => typeof segment === "number" ? 0 : segment);
-        const id = pathId(schemaPath);
-        let found = this.#constraints.get(id);
-        if (found === undefined) {
-            found = constraintsAt(this.definition.schema.ast, schemaPath);
-            this.#constraints.set(id, found);
-        }
-        return found;
+        // Reads the values only for a tuple with elements after its rest, whose fields move as it grows.
+        return constraintsAt(this.definition.schema.ast, path, (arrayPath) => {
+            const array = getIn(this.values, arrayPath);
+            return Array.isArray(array) ? array.length : undefined;
+        });
     }
     field(path) {
         const id = pathId(path);

package/dist/internal/form/issues.js

@@ -66,6 +66,9 @@ const emitDefault = (issue, path, emit) => {
         emit([...path, ...(formatted.path ?? [])], formatted.message);
     }
 };
+const asInvalidType = (issue) => new SchemaIssue.InvalidType(issue.ast, issue.input, {
+    reportInput: SchemaIssue.hasInput(issue),
+});
 const walkFilter = (issue, path, hooks, emit, walk) => {
     const pointed = pointedPaths(issue.issue, path);
     const annotated = findMessage(issue.issue) ?? findMessage(issue);
@@ -119,8 +122,13 @@ export const toPathIssues = (issue, hooks) => {
             }
             case "Composite":
             case "AnyOf": {
-                if (current.issues.length === 0) {
-                    emitDefault(current, path, emit);
+                // A value no member of the union applies to (one outside a Literals, say) fails with no
+                // inner issues. Effect's formatter reports it without calling a hook. Walked here as the
+                // InvalidType a single Literal gives, so `leafHook` names it, and the fallback is
+                // Effect's same `Expected "a" | "b"`.
+                if (current._tag === "AnyOf" && current.issues.length === 0) {
+                    walk(asInvalidType(current), path);
+                    return;
                 }
                 for (const inner of current.issues) {
                     walk(inner, path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-atom-svelte",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Community-built Svelte 5 bindings for Effect Atom (not affiliated with the Effect team)",
   "keywords": [
     "effect",