attaform 0.30.0 → 0.31.0

package/dist/shared/{attaform.BK0cgu2K.mjs → attaform.DBCbxlyk.mjs}

@@ -119,6 +119,20 @@ const NATIVE_FORM_TAGS = /* @__PURE__ */ new Set([
   "label",
   "button"
 ]);
+const HOST_MODIFIERS = ["lazy", "trim", "number"];
+function hostModifiersLiteral(registerDirective) {
+  const present = HOST_MODIFIERS.filter(
+    (name) => registerDirective?.modifiers.some((m) => m.content === name) === true
+  );
+  return present.length === 0 ? "{}" : `{ ${present.map((name) => `${name}: true`).join(", ")} }`;
+}
+function isInputListenerSlot(prop) {
+  if (prop.type !== NodeTypes.DIRECTIVE || prop.name !== "on" && prop.name !== "bind") {
+    return false;
+  }
+  if (prop.arg === void 0) return true;
+  return prop.arg.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === (prop.name === "on" ? "input" : "onInput");
+}
 function inferOptionValueFromChildren(node) {
   if (!("children" in node)) return null;
   const children = node.children;
@@ -275,6 +289,11 @@ const componentBridgeTransform = (node, context) => {
       node.props.push(valueProp);
     }
     if (isPlainComponentHost) {
+      const hostModifiers = hostModifiersLiteral(
+        node.props.find(
+          (p) => p.type === NodeTypes.DIRECTIVE && p.name === "register"
+        )
+      );
       removePropsByName(node.props, [
         "model",
         "modelValue",
@@ -317,7 +336,7 @@ const componentBridgeTransform = (node, context) => {
       const updateInitExpression = createCompoundExpression([
         "$event => (",
         ...modelValuePropExpArray,
-        ")?.setValueFromHost?.($event)"
+        `)?.setValueFromHost?.($event, ${hostModifiers})`
       ]);
       const updateSimpleExpression = createSimpleExpression(
         flattenExpression(updateInitExpression),
@@ -346,6 +365,45 @@ const componentBridgeTransform = (node, context) => {
         loc: selectLoc
       };
       node.props.push(updateModelValueProp);
+      const inputAlreadyInjected = node.props.some(
+        (p) => p.type === NodeTypes.DIRECTIVE && p.name === "bind" && p.arg?.type === NodeTypes.SIMPLE_EXPRESSION && p.arg.content === "onInput" && p.exp !== void 0 && flattenExpression(p.exp).includes("setValueFromHostInput")
+      );
+      if (!inputAlreadyInjected) {
+        const inputInitExpression = createCompoundExpression([
+          "$event => (",
+          ...modelValuePropExpArray,
+          `)?.setValueFromHostInput?.($event, ${hostModifiers})`
+        ]);
+        const inputSimpleExpression = createSimpleExpression(
+          flattenExpression(inputInitExpression),
+          false
+        );
+        let inputOutputExp;
+        try {
+          inputOutputExp = processExpression(inputSimpleExpression, {
+            ...context,
+            prefixIdentifiers: false
+          });
+        } catch (err) {
+          console.error(
+            "[attaform] component-bridge transform: processExpression failed for onInput; falling back to the unprocessed expression.",
+            err
+          );
+          inputOutputExp = inputSimpleExpression;
+        }
+        const inputProp = {
+          rawName: "@input",
+          arg: createSimpleExpression("onInput", true),
+          exp: inputOutputExp,
+          name: "bind",
+          modifiers: [],
+          type: NodeTypes.DIRECTIVE,
+          loc: selectLoc
+        };
+        const authorListenerIndex = node.props.findIndex(isInputListenerSlot);
+        if (authorListenerIndex === -1) node.props.push(inputProp);
+        else node.props.splice(authorListenerIndex, 0, inputProp);
+      }
     }
     const registerExprArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
     const hasAuthorDisabled = selectSummarizedProps.findIndex((p) => isExactKey(p.key, "disabled")) !== -1;
@@ -756,9 +814,9 @@ function injectPreamble(element, captured) {
     ),
     exp,
     modifiers: [],
-    // Reuse the host element's source location so any runtime error
-    // in the synthesized expression points at the consumer's template
-    // line, not at the dummyLoc that pre-fix was line 0.
+    // The host element's source location, so a runtime error in the
+    // synthesized expression points at the consumer's template line
+    // rather than at line 0.
     loc: element.loc
   };
   element.props.unshift(directive);

package/dist/shared/{attaform.CUfrMK7t.mjs → attaform.DL2nl_QR.mjs}

@@ -1,6 +1,6 @@
-import { A as AttaformErrorCode, k as isPlainRecord, s as slimKindOf } from './attaform.DNJOWjQw.mjs';
+import { A as AttaformErrorCode, k as isPlainRecord, s as slimKindOf } from './attaform.DNPJPOO7.mjs';
 import { e as canonicalizePath, h as SET_MEMBER_SEGMENT } from './attaform.CdZIEf7_.mjs';
-import { a as safeOwnRead, b as safeAssign } from './attaform.BRDDQeHV.mjs';
+import { a as safeOwnRead, b as safeAssign } from './attaform.8mfKZCwH.mjs';
 
 const PATH_SEPARATOR = ".";
 function isOpaqueKind(kind) {
@@ -37,9 +37,6 @@ function createAbstractSchema(rootSchema, intro, services, options) {
   const discriminatorCache = /* @__PURE__ */ new Map();
   const entryKeyKindCache = /* @__PURE__ */ new Map();
   const slimKindsCache = /* @__PURE__ */ new Map();
-  let asyncValidationFlag = null;
-  let containerRefineFlag = null;
-  let discriminatedUnionFlag = null;
   function mapKeySegmentKind(schema) {
     const keyType = intro.getMapKeyType(schema);
     if (keyType === void 0) return void 0;
@@ -92,20 +89,24 @@ function createAbstractSchema(rootSchema, intro, services, options) {
   }
   const abstractSchema = {
     needsAsyncValidation() {
-      asyncValidationFlag ?? (asyncValidationFlag = intro.containsAsyncRefine(rootSchema) || intro.containsAsyncTransform(rootSchema));
-      return asyncValidationFlag;
+      const { asyncRefine, asyncTransform } = intro.capabilitiesOf(rootSchema);
+      return asyncRefine || asyncTransform;
     },
     hasContainerOrRootRefine() {
-      containerRefineFlag ?? (containerRefineFlag = intro.hasContainerOrRootRefine(rootSchema));
-      return containerRefineFlag;
+      return intro.capabilitiesOf(rootSchema).containerOrRootRefine;
     },
     hasDiscriminatedUnions() {
-      discriminatedUnionFlag ?? (discriminatedUnionFlag = intro.containsDiscriminatedUnion(rootSchema));
-      return discriminatedUnionFlag;
+      return intro.capabilitiesOf(rootSchema).discriminatedUnion;
+    },
+    hasPreprocessOrCoerce() {
+      return intro.capabilitiesOf(rootSchema).preprocessOrCoerce;
     },
     getDefaultValues(config) {
       return services.runGetDefaults(rootSchema, config, maxRecursionDepth);
     },
+    validateSync(data) {
+      return services.validateSync(rootSchema, data);
+    },
     getDefaultAtPath(path) {
       if (path.length === 0) {
         return services.deriveDefault(rootSchema, true, maxRecursionDepth);
@@ -425,8 +426,8 @@ function walkPathSegments(schema, segments, intro, maxDepth, lazyDepth) {
       const rightResults = right === void 0 ? [] : walkPathSegments(right, segments, intro, maxDepth, lazyDepth);
       return [...leftResults, ...rightResults];
     }
-    // Leaves — can't descend further. Opaque leaves (`any` /
-    // `unknown` / `custom`) land here too and `[]` is the truthful
+    // Leaves, with nothing further to descend. An opaque leaf (`any` /
+    // `unknown` / `custom`) lands here too and `[]` is the truthful
     // answer: the schema declares no sub-paths under them, so none are
     // fabricated. `symbol` / `function` / `promise` hold a value
     // without declaring anything inside it and land here for the same
@@ -1017,7 +1018,7 @@ function slimPrimitivesWalk(schema, intro, maxDepth, lazyDepth = 0) {
     case "unknown":
     case "custom":
       return PERMISSIVE_SLIM_KINDS;
-    // A kind this walker has no case for — in practice a kind a newer
+    // A kind this walker has no case for, in practice one a newer
     // Zod introduced. Be permissive rather than reject: the adapter
     // carries the value opaquely and the schema's own parse is what
     // decides whether it was legal.