attaform 0.27.6 → 0.29.0

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

@@ -1,4 +1,4 @@
-import { NodeTypes, createCompoundExpression, createSimpleExpression, ElementTypes, processExpression } from '@vue/compiler-core';
+import { NodeTypes, ElementTypes, createCompoundExpression, createSimpleExpression, processExpression } from '@vue/compiler-core';
 import { S as SSR_COMPONENT_HOST_MODIFIER, V as V_REGISTER_COMPILED_MODIFIER } from './attaform.KvlEedlF.mjs';
 
 function getSummarizedProps(node) {
@@ -40,6 +40,10 @@ function removePropsByName(props, propNames) {
     props.splice(index, 1);
   }
 }
+function toExpressionArray(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
 function isExactKey(summarizedKey, name) {
   return summarizedKey === name || summarizedKey === `"${name}"`;
 }
@@ -64,54 +68,13 @@ function flattenExpression(exp) {
   return out;
 }
 
-function generateEqualityExpression$1(selectValue, optionValue, previousOptionExpressions) {
-  const multipleExpression = previousOptionExpressions?.[0];
-  if (multipleExpression === void 0) {
-    throw new Error(
-      "Programming error: `multiple` expression for `select` node not generated while transforming AST"
-    );
-  }
-  const optExpressions = previousOptionExpressions.slice(1);
-  const noMultipleOptExpressions = optExpressions.reduce(
-    (acc, curr, index) => {
-      if (index === 0) {
-        acc.push("(");
-      }
-      acc.push(...curr);
-      if (index < optExpressions.length - 1) {
-        acc.push(" || ");
-      }
-      if (index === optExpressions.length - 1) {
-        acc.push(")");
-      }
-      return acc;
-    },
-    []
-  );
+function generateEqualityExpression$1(selectValue, optionValue, multipleExpression) {
   const selectValueArr = Array.isArray(selectValue) ? selectValue : [selectValue];
   const optionValueArr = Array.isArray(optionValue) ? optionValue : [optionValue];
   function getImplicitTrueMultipleExpression(expression) {
     if (expression.length === 1 && expression[0] === "") return [`true`];
     return expression;
   }
-  previousOptionExpressions.push(["(", ...selectValueArr, ") === (", ...optionValueArr, ")"]);
-  if (!noMultipleOptExpressions.length) {
-    return [
-      "(",
-      ...getImplicitTrueMultipleExpression(multipleExpression),
-      `) ? ((`,
-      ...selectValueArr,
-      `)?.innerRef?.value?.findIndex?.(el => el === (`,
-      ...optionValueArr,
-      `)) > -1) : (typeof (`,
-      ...selectValueArr,
-      `)?.innerRef?.value !== 'object' && String((`,
-      ...selectValueArr,
-      `)?.innerRef?.value) === String((`,
-      ...optionValueArr,
-      `)))`
-    ];
-  }
   return [
     "(",
     ...getImplicitTrueMultipleExpression(multipleExpression),
@@ -119,16 +82,13 @@ function generateEqualityExpression$1(selectValue, optionValue, previousOptionEx
     ...selectValueArr,
     `)?.innerRef?.value?.findIndex?.(el => el === (`,
     ...optionValueArr,
-    `)) > -1) : ((`,
-    ...noMultipleOptExpressions,
-    // if true, we already found the relevant option
-    `) ? false : (typeof (`,
+    `)) > -1) : (typeof (`,
     ...selectValueArr,
-    `)?.innerRef?.value !== 'object' && String((`,
+    `)?.innerRef?.value !== 'object' && (`,
     ...selectValueArr,
-    `)?.innerRef?.value) === String((`,
+    `)?.displayValue?.value === String((`,
     ...optionValueArr,
-    `))))`
+    `)))`
   ];
 }
 function extractMultipleFromSelectSummarizedProps(props) {
@@ -143,7 +103,7 @@ function extractMultipleFromSelectSummarizedProps(props) {
   const value = props[priorityIndex]?.value;
   return typeof value === "string" ? value.replace(/'|"/g, "") : value ?? "true";
 }
-const RECURSABLE_NODE_TYPES$1 = /* @__PURE__ */ new Set([
+const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
   NodeTypes.ELEMENT,
   NodeTypes.FOR,
   NodeTypes.IF,
@@ -170,6 +130,57 @@ function inferOptionValueFromChildren(node) {
   const text = only.content.trim();
   return JSON.stringify(text);
 }
+const pendingOptionBindings = /* @__PURE__ */ new WeakMap();
+function applyPendingOptionBinding(node, pending) {
+  const optionProps = getSummarizedProps(node);
+  const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
+  let optionValueSummarizedProp;
+  if (valueIndex >= 0 && valueIndex < optionProps.length) {
+    optionValueSummarizedProp = optionProps[valueIndex];
+  } else {
+    const fallback = inferOptionValueFromChildren(node);
+    if (fallback === null) {
+      return;
+    }
+    optionValueSummarizedProp = { key: "value", value: fallback };
+  }
+  const props = node.props;
+  const snapshot = [...props];
+  try {
+    removePropsByName(props, ["selected"]);
+    const authorSelectedArr = toExpressionArray(
+      optionProps.find((p) => isExactKey(p.key, "selected"))?.value
+    );
+    const registerArr = toExpressionArray(pending.registerValue) ?? ["undefined"];
+    const boundExpression = generateEqualityExpression$1(
+      pending.registerValue,
+      optionValueSummarizedProp?.value ?? "undefined",
+      pending.multiple
+    );
+    props.push({
+      arg: createSimpleExpression("selected", true),
+      exp: createCompoundExpression(
+        authorSelectedArr === void 0 ? boundExpression : [
+          "((",
+          ...registerArr,
+          ") == null ? (",
+          ...authorSelectedArr,
+          ") : (",
+          ...boundExpression,
+          "))"
+        ]
+      ),
+      name: "bind",
+      modifiers: [],
+      type: NodeTypes.DIRECTIVE,
+      loc: node.loc
+    });
+  } catch (err) {
+    props.length = 0;
+    props.push(...snapshot);
+    console.error("[attaform] component-bridge transform: option binding failed, skipping:", err);
+  }
+}
 const componentBridgeTransform = (node, context) => {
   const snapshots = [];
   const snapshotProps = (target) => {
@@ -177,51 +188,33 @@ const componentBridgeTransform = (node, context) => {
     snapshots.push({ target, snapshot: [...target] });
   };
   try {
-    let traverseSelectNode = function(_node, previousOptionExpressions2) {
+    let traverseSelectNode = function(_node, multipleExpression2) {
       const isOption = _node.type === NodeTypes.ELEMENT && _node.tag === "option";
       if (!isOption) {
-        if (!RECURSABLE_NODE_TYPES$1.has(_node.type)) return;
+        if (!RECURSABLE_NODE_TYPES.has(_node.type)) return;
         const hasChildren = "children" in _node;
         if (!hasChildren) return;
         for (const child of _node.children) {
           if (typeof child === "symbol" || typeof child === "string") continue;
           if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
-          traverseSelectNode(child, previousOptionExpressions2);
+          traverseSelectNode(child, multipleExpression2);
         }
         return;
       }
       hasSlottedOptions = true;
-      const optionProps = getSummarizedProps(_node);
-      const valueIndex = optionProps.findIndex((p) => isExactKey(p.key, "value"));
-      let optionValueSummarizedProp;
-      if (valueIndex >= 0 && valueIndex < optionProps.length) {
-        optionValueSummarizedProp = optionProps[valueIndex];
-      } else {
-        const fallback = inferOptionValueFromChildren(_node);
-        if (fallback === null) {
-          return;
-        }
-        optionValueSummarizedProp = { key: "value", value: fallback };
-      }
-      const props = _node.props;
-      snapshotProps(props);
-      removePropsByName(props, ["selected"]);
-      const newProp = {
-        arg: createSimpleExpression("selected", true),
-        exp: createCompoundExpression(
-          generateEqualityExpression$1(
-            registerSummarizedProp?.value ?? "undefined",
-            optionValueSummarizedProp?.value ?? "undefined",
-            previousOptionExpressions2
-          )
-        ),
-        name: "bind",
-        modifiers: [],
-        type: NodeTypes.DIRECTIVE,
-        loc: _node.loc
-      };
-      props.push(newProp);
+      pendingOptionBindings.set(_node, {
+        registerValue: registerSummarizedProp?.value ?? "undefined",
+        multiple: multipleExpression2
+      });
     };
+    if (node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.ELEMENT) {
+      const pending = pendingOptionBindings.get(node);
+      if (pending !== void 0) {
+        pendingOptionBindings.delete(node);
+        applyPendingOptionBinding(node, pending);
+        return;
+      }
+    }
     const isSelect = node.type === NodeTypes.ELEMENT && node.tag === "select";
     const isCustomComponent = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.COMPONENT;
     const isKebabCustomElement = node.type === NodeTypes.ELEMENT && node.tagType === ElementTypes.ELEMENT && node.tag.includes("-") && !NATIVE_FORM_TAGS.has(node.tag);
@@ -233,25 +226,32 @@ const componentBridgeTransform = (node, context) => {
     const registerSummarizedProp = selectSummarizedProps[registerIndex];
     const selectLoc = node.loc;
     let hasSlottedOptions = false;
-    const multipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
-    const previousOptionExpressions = typeof multipleExpression === "string" ? [[multipleExpression]] : [multipleExpression];
+    const rawMultipleExpression = extractMultipleFromSelectSummarizedProps(selectSummarizedProps);
+    const multipleExpression = typeof rawMultipleExpression === "string" ? [rawMultipleExpression] : rawMultipleExpression;
     for (const child of node.children) {
-      traverseSelectNode(child, previousOptionExpressions);
+      traverseSelectNode(child, multipleExpression);
     }
-    const isStaticallyNonMultiple = multipleExpression === "false";
+    const isStaticallyNonMultiple = rawMultipleExpression === "false";
     const isComponentHost = isCustomComponent || isKebabCustomElement;
     const isSelectLikeHost = isSelect || isComponentHost && hasSlottedOptions;
     const isPlainComponentHost = isComponentHost && !hasSlottedOptions;
     const selectProps = node.props;
+    const authorSelectValueArr = toExpressionArray(
+      selectSummarizedProps.find((p) => isExactKey(p.key, "value"))?.value
+    );
     snapshotProps(selectProps);
     removePropsByName(selectProps, ["value"]);
     if (isStaticallyNonMultiple && isSelectLikeHost) {
       const valuePropExpArray = Array.isArray(registerSummarizedProp?.value) ? registerSummarizedProp.value : [registerSummarizedProp?.value ?? "undefined"];
-      const initExpression = createCompoundExpression([
-        "(",
-        ...valuePropExpArray,
-        ")?.displayValue.value"
-      ]);
+      const initExpression = createCompoundExpression(
+        authorSelectValueArr === void 0 ? ["(", ...valuePropExpArray, ")?.displayValue.value"] : [
+          "((",
+          ...valuePropExpArray,
+          ")?.displayValue.value ?? (",
+          ...authorSelectValueArr,
+          "))"
+        ]
+      );
       const simpleExpression = createSimpleExpression(flattenExpression(initExpression), false);
       let outputExp;
       try {
@@ -470,26 +470,41 @@ const inputTextAreaNodeTransform = (node) => {
       const isStaticRadio = typeProp !== void 0 && isStaticTypeOneOf(typeProp.value, ["radio"]);
       const isDynamicType = typeProp !== void 0 && isDynamicTypeValue(typeProp.value);
       const keepStaticValue = isStaticCheckbox || isStaticRadio || isDynamicType;
+      const authorCheckedProp = elementProps.find((p) => isExactKey(p.key, "checked"));
+      const authorValueProp = keepStaticValue ? void 0 : elementProps.find((p) => isExactKey(p.key, "value"));
       removePropsByName(props, keepStaticValue ? ["checked"] : ["checked", "value"]);
       const registerValueArr = Array.isArray(registerSummarizedProp2.value) ? registerSummarizedProp2.value : [registerSummarizedProp2.value];
-      const valueExpression = createCompoundExpression([
-        "(",
-        ...registerValueArr,
-        ")?.displayValue?.value"
-      ]);
+      const authorValueArr = toExpressionArray(authorValueProp?.value);
+      const valueExpression = createCompoundExpression(
+        authorValueArr === void 0 ? ["(", ...registerValueArr, ")?.displayValue?.value"] : ["((", ...registerValueArr, ")?.displayValue?.value ?? (", ...authorValueArr, "))"]
+      );
       const trueValueIndex = elementProps.findIndex((p) => isExactKey(p.key, "true-value"));
       const trueValueProp = elementProps[trueValueIndex];
       const scalarTarget = isStaticCheckbox ? trueValueProp !== void 0 ? trueValueProp.value : "true" : elementValueSummarizedProp2.value;
-      const coreExpression = [
-        "(",
-        ...elementSelectionLabelExpression.children,
-        ") === 'checked' ? (",
-        // resolves to a boolean
+      const authorCheckedArr = toExpressionArray(authorCheckedProp?.value);
+      const checkedExpression = authorCheckedArr === void 0 ? generateEqualityExpression(
+        registerSummarizedProp2.value,
+        elementValueSummarizedProp2.value,
+        scalarTarget
+      ) : [
+        "((",
+        ...registerValueArr,
+        ") == null ? (",
+        ...authorCheckedArr,
+        ") : (",
         ...generateEqualityExpression(
           registerSummarizedProp2.value,
           elementValueSummarizedProp2.value,
           scalarTarget
         ),
+        "))"
+      ];
+      const coreExpression = [
+        "(",
+        ...elementSelectionLabelExpression.children,
+        ") === 'checked' ? (",
+        // resolves to a boolean
+        ...checkedExpression,
         ") : (",
         // resolves to the provided register value
         ...valueExpression.children,
@@ -562,22 +577,10 @@ const inputTextAreaNodeTransform = (node) => {
   }
 };
 
-const RECURSABLE_NODE_TYPES = /* @__PURE__ */ new Set([
-  NodeTypes.ELEMENT,
-  NodeTypes.FOR,
-  NodeTypes.IF,
-  NodeTypes.IF_BRANCH
-]);
-function findRedundantStateBinding(props, stateNames) {
+function findRedundantStateBinding(props) {
   for (const prop of props) {
-    if (prop.type === NodeTypes.ATTRIBUTE) {
-      if (stateNames.includes(prop.name)) return prop.name;
-      continue;
-    }
+    if (prop.type === NodeTypes.ATTRIBUTE) continue;
     if (prop.name === "model") return "v-model";
-    if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic && stateNames.includes(prop.arg.content)) {
-      return `:${prop.arg.content}`;
-    }
   }
   return null;
 }
@@ -602,42 +605,23 @@ function emitRedundantWarning(tag, binding) {
     `[attaform] \`${binding}\` is redundant beside v-register on <${tag}>. v-register already drives this field's value, so keep v-register alone and drop \`${binding}\`. (An identity \`:value\` on a radio or <option> is expected and stays silent.)`
   );
 }
-function walkOptionsForSelected(selectNode) {
-  const visit = (candidate) => {
-    if (candidate.type === NodeTypes.ELEMENT && candidate.tag === "option") {
-      const found = findRedundantStateBinding(candidate.props, ["selected"]);
-      if (found !== null) emitRedundantWarning("option", found);
-      return;
-    }
-    if (!RECURSABLE_NODE_TYPES.has(candidate.type)) return;
-    if (!("children" in candidate)) return;
-    for (const child of candidate.children) {
-      if (typeof child === "string" || typeof child === "symbol") continue;
-      if (child.type === NodeTypes.SIMPLE_EXPRESSION) continue;
-      visit(child);
-    }
-  };
-  for (const child of selectNode.children) visit(child);
-}
 function warnIfRedundant(node) {
   if (node.tagType !== ElementTypes.ELEMENT) return;
   const tag = node.tag;
   if (tag === "select") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    const found2 = findRedundantStateBinding(node.props);
     if (found2 !== null) emitRedundantWarning("select", found2);
-    walkOptionsForSelected(node);
     return;
   }
   if (tag === "textarea") {
-    const found2 = findRedundantStateBinding(node.props, ["value"]);
+    const found2 = findRedundantStateBinding(node.props);
     if (found2 !== null) emitRedundantWarning("textarea", found2);
     return;
   }
   if (tag !== "input") return;
   const kind = classifyInput(node.props);
   if (kind === "dynamic" || kind === "file") return;
-  const stateNames = kind === "checkbox" || kind === "radio" ? ["checked"] : ["value"];
-  const found = findRedundantStateBinding(node.props, stateNames);
+  const found = findRedundantStateBinding(node.props);
   if (found !== null) emitRedundantWarning("input", found);
 }
 const redundantBindingWarnTransform = (node) => {
@@ -791,4 +775,3 @@ function hasPreamble(element) {
 }
 
 export { vRegisterPreambleTransform as a, componentBridgeTransform as c, inputTextAreaNodeTransform as i, redundantBindingWarnTransform as r, vRegisterHintTransform as v };
-//# sourceMappingURL=attaform.Cs2Rbdlo.mjs.map

package/dist/shared/{attaform.B9Wyhfro.cjs → attaform.BndjUUYX.mjs}

@@ -1,9 +1,7 @@
-'use strict';
-
-const devtoolsShared = require('./attaform.Biytrv0-.cjs');
-const useForm$1 = require('./attaform.D8kliaKw.cjs');
-const index = require('./attaform.DdQN7sgN.cjs');
-const walkFieldMeta = require('./attaform.D6tk90Rc.cjs');
+import { a as InvalidUseFormConfigError } from './attaform.CZYt_5N_.mjs';
+import { u as useForm$2 } from './attaform.D1fnTifF.mjs';
+import { u as useForm$1 } from './attaform.C2MVyuxC.mjs';
+import { i as installingFieldMetaStore, g as getFieldMetaForSchema } from './attaform.B0dKL8ST.mjs';
 
 function isZodV4SchemaShape(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -14,21 +12,21 @@ function isZodV4SchemaShape(value) {
 
 function useForm(configuration) {
   if (configuration === void 0 || configuration === null || configuration.schema === void 0) {
-    throw new devtoolsShared.InvalidUseFormConfigError();
+    throw new InvalidUseFormConfigError();
   }
   const { schema } = configuration;
   if (isZodV4SchemaShape(schema)) {
-    return index.useForm(configuration);
+    return useForm$1(configuration);
   }
-  return useForm$1.useForm(configuration);
+  return useForm$2(configuration);
 }
 
-const fieldMeta = walkFieldMeta.fieldMetaStore;
+const fieldMeta = installingFieldMetaStore;
 function withMeta(schema, payload) {
   const target = schema;
-  const existing = walkFieldMeta.getFieldMetaForSchema(target) ?? {};
+  const existing = getFieldMetaForSchema(target) ?? {};
   const cloned = cloneSchema(schema);
-  walkFieldMeta.fieldMetaStore.add(cloned, { ...existing, ...payload });
+  installingFieldMetaStore.add(cloned, { ...existing, ...payload });
   return cloned;
 }
 function cloneSchema(schema) {
@@ -40,7 +38,4 @@ function cloneSchema(schema) {
   return new Ctor(candidate._def);
 }
 
-exports.fieldMeta = fieldMeta;
-exports.useForm = useForm;
-exports.withMeta = withMeta;
-//# sourceMappingURL=attaform.B9Wyhfro.cjs.map
+export { fieldMeta as f, useForm as u, withMeta as w };

package/dist/shared/{attaform.CQN9R62B.cjs → attaform.BxfsuwBR.mjs}

@@ -1,5 +1,3 @@
-'use strict';
-
 function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
@@ -26,6 +24,14 @@ function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
     try {
       if (value instanceof Date) return `date:${value.getTime()}`;
       if (value instanceof RegExp) return `regex:${String(value)}`;
+      if (value instanceof Map) {
+        const entries2 = [...value].map(([k, v]) => `${canonicalStringify(k, seen)}=>${canonicalStringify(v, seen)}`).sort();
+        return `map:[${entries2.join(",")}]`;
+      }
+      if (value instanceof Set) {
+        const members = [...value].map((v) => canonicalStringify(v, seen)).sort();
+        return `set:[${members.join(",")}]`;
+      }
       const entries = Object.entries(obj).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalStringify(v, seen)}`);
       return `{${entries.join(",")}}`;
     } finally {
@@ -35,5 +41,4 @@ function canonicalStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
   return "unknown";
 }
 
-exports.canonicalStringify = canonicalStringify;
-//# sourceMappingURL=attaform.CQN9R62B.cjs.map
+export { canonicalStringify as c };