@foormjs/vue 0.0.3 → 0.2.0

package/dist/index.js

@@ -1,22 +1,30 @@
-import { defineComponent as q, mergeModels as I, useModel as L, inject as O, ref as k, computed as i, watch as R, onUnmounted as T, getCurrentInstance as N, renderSlot as _, unref as x, provide as W, openBlock as p, createElementBlock as V, withModifiers as G, nextTick as J, createBlock as B, withCtx as w, toDisplayString as h, createCommentVNode as j, Fragment as K, renderList as Q, normalizeProps as A, guardReactiveProps as M, resolveDynamicComponent as F, mergeProps as H, normalizeClass as X, createElementVNode as $, withDirectives as Y, vModelDynamic as Z } from "vue";
-function C(n, r) {
-  return U(n) ? n(r) : n;
+var X = Object.defineProperty;
+var Q = (n, t, o) => t in n ? X(n, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : n[t] = o;
+var N = (n, t, o) => Q(n, typeof t != "symbol" ? t + "" : t, o);
+import { defineComponent as T, useModel as R, inject as P, ref as w, computed as m, watch as W, onUnmounted as Y, getCurrentInstance as U, renderSlot as A, unref as B, mergeModels as J, provide as K, openBlock as x, createElementBlock as E, withModifiers as Z, nextTick as ee, createBlock as q, withCtx as O, toDisplayString as F, createCommentVNode as H, Fragment as te, renderList as oe, mergeProps as $, resolveDynamicComponent as z, normalizeClass as ne, createElementVNode as M, withDirectives as le, vModelDynamic as re, reactive as ae } from "vue";
+function b(n, t) {
+  return typeof n == "function" ? n(t) : n;
 }
-function S(n, r) {
-  if (typeof n == "object" && n !== null) {
-    const o = {};
-    for (const [t, m] of Object.entries(n))
-      o[t] = C(m, r);
-    return o;
-  }
-  return U(n) ? n(r) : n;
+function ue(n) {
+  var t;
+  const o = {};
+  for (const r of n)
+    r.type !== "action" && (o[r.field] = (t = r.value) !== null && t !== void 0 ? t : void 0);
+  return o;
+}
+function se(n, t) {
+  return n.fields.some((o) => o.altAction === t);
 }
-function U(n) {
-  return typeof n == "function";
+function ie(n, t) {
+  if (!n) return;
+  const o = {};
+  for (const [r, a] of Object.entries(n))
+    o[r] = b(a, t);
+  return o;
 }
-const ee = /* @__PURE__ */ q({
+const ce = /* @__PURE__ */ T({
   __name: "VuilessField",
-  props: /* @__PURE__ */ I({
+  props: /* @__PURE__ */ J({
     rules: {}
   }, {
     modelValue: {},
@@ -24,74 +32,74 @@ const ee = /* @__PURE__ */ q({
   }),
   emits: ["update:modelValue"],
   setup(n) {
-    const r = n, o = L(n, "modelValue"), t = O("vuiless"), m = k(), d = k(!1), b = k(!1), v = i(() => {
-      var a;
-      if ((a = t == null ? void 0 : t.value) != null && a.firstValidation)
-        switch (t.value.firstValidation) {
+    const t = n, o = R(n, "modelValue"), r = P("vuiless"), a = w(), d = w(!1), v = w(!1), f = m(() => {
+      var c;
+      if ((c = r == null ? void 0 : r.value) != null && c.firstValidation)
+        switch (r.value.firstValidation) {
           case "on-change":
-            return t.value.firstSubmitHappened || d.value;
+            return r.value.firstSubmitHappened || d.value;
           case "touched-on-blur":
-            return t.value.firstSubmitHappened || b.value && d.value;
+            return r.value.firstSubmitHappened || v.value && d.value;
           case "on-blur":
-            return t.value.firstSubmitHappened || b.value;
+            return r.value.firstSubmitHappened || v.value;
           case "on-submit":
-            return t.value.firstSubmitHappened;
+            return r.value.firstSubmitHappened;
           case "none":
             return !1;
         }
       return !1;
-    }), y = i(() => {
-      if (v.value || m.value)
-        return l();
+    }), g = m(() => {
+      if (f.value || a.value)
+        return V();
     });
-    R([o], () => {
-      m.value = void 0, d.value = !0;
-    }), T(() => {
-      var a;
-      (a = t == null ? void 0 : t.value) == null || a.unregister(N());
-    }), t != null && t.value && t.value.register(N(), {
-      validate: () => (m.value = l(), m.value || !0),
+    W([o], () => {
+      a.value = void 0, d.value = !0;
+    }), Y(() => {
+      var c;
+      (c = r == null ? void 0 : r.value) == null || c.unregister(U());
+    }), r != null && r.value && r.value.register(U(), {
+      validate: () => (a.value = V(), a.value || !0),
       clearErrors: () => {
-        d.value = !1, b.value = !1, m.value = void 0;
+        d.value = !1, v.value = !1, a.value = void 0;
       },
       reset: () => {
         o.value = "";
       }
     });
-    function l() {
-      var a, e, f;
-      if ((a = r.rules) != null && a.length)
-        for (const g of r.rules) {
-          const u = g(
+    function V() {
+      var c, l, u;
+      if ((c = t.rules) != null && c.length)
+        for (const y of t.rules) {
+          const e = y(
             o.value,
-            (e = t == null ? void 0 : t.value) == null ? void 0 : e.formData,
-            (f = t == null ? void 0 : t.value) == null ? void 0 : f.formContext
+            (l = r == null ? void 0 : r.value) == null ? void 0 : l.formData,
+            (u = r == null ? void 0 : r.value) == null ? void 0 : u.formContext
           );
-          if (u !== !0)
-            return u || "Wrong value";
+          if (e !== !0)
+            return e || "Wrong value";
         }
     }
-    function c() {
-      b.value = !0;
+    function i() {
+      v.value = !0;
     }
     const s = {
-      v: i({
+      v: m({
         get: () => o.value,
-        set: (a) => o.value = a
+        set: (c) => o.value = c
       })
     };
-    return (a, e) => {
-      var f, g;
-      return _(a.$slots, "default", {
-        onBlur: c,
-        error: y.value,
-        formData: (f = x(t)) == null ? void 0 : f.formData,
-        formContext: (g = x(t)) == null ? void 0 : g.formContext,
+    return (c, l) => {
+      var u, y;
+      return A(c.$slots, "default", {
+        onBlur: i,
+        error: g.value,
+        formData: (u = B(r)) == null ? void 0 : u.formData,
+        formContext: (y = B(r)) == null ? void 0 : y.formContext,
         model: s.v
       });
     };
   }
-}), te = /* @__PURE__ */ q({
+}), me = /* @__PURE__ */ T({
   __name: "VuilessForm",
   props: {
     formData: {},
@@ -99,145 +107,153 @@ const ee = /* @__PURE__ */ q({
     firstValidation: { default: "on-change" }
   },
   emits: ["submit"],
-  setup(n, { emit: r }) {
-    const o = n, t = r, m = /* @__PURE__ */ new Map(), d = k(!1), b = i(() => ({
+  setup(n, { emit: t }) {
+    const o = n, r = t, a = /* @__PURE__ */ new Map(), d = w(!1), v = m(() => ({
       firstSubmitHappened: d.value,
       firstValidation: o.firstValidation,
-      register: (c, s) => {
-        m.set(c, s);
+      register: (i, s) => {
+        a.set(i, s);
       },
-      unregister: (c) => m.delete(c),
+      unregister: (i) => a.delete(i),
       formData: o.formData,
       formContext: o.formContext
     }));
-    W("vuiless", b);
-    function v() {
+    K("vuiless", v);
+    function f() {
       d.value = !1;
-      for (const { clearErrors: c } of m.values())
-        c();
+      for (const { clearErrors: i } of a.values())
+        i();
     }
-    async function y() {
-      for (const { reset: c } of m.values())
-        c();
-      await J(), v();
+    async function g() {
+      for (const { reset: i } of a.values())
+        i();
+      await ee(), f();
     }
-    function l() {
+    function V() {
       d.value = !0;
-      let c = !1;
+      let i = !1;
       if (o.firstValidation !== "none")
-        for (const { validate: s } of m.values())
-          s() !== !0 && (c = !0);
-      c || t("submit", o.formData);
+        for (const { validate: s } of a.values())
+          s() !== !0 && (i = !0);
+      i || r("submit", o.formData);
     }
-    return (c, s) => (p(), V("form", {
-      onSubmit: G(l, ["prevent"])
+    return (i, s) => (x(), E("form", {
+      onSubmit: Z(V, ["prevent"])
     }, [
-      _(c.$slots, "default", {
-        clearErrors: v,
-        reset: y
+      A(i.$slots, "default", {
+        clearErrors: f,
+        reset: g
       })
     ], 32));
   }
-}), oe = /* @__PURE__ */ q({
+}), de = /* @__PURE__ */ T({
   __name: "oo-field",
   props: {
     field: {},
-    altAction: {},
-    label: {},
-    description: {},
-    hint: {},
-    placeholder: {},
-    classes: {},
-    styles: {},
     type: {},
     component: {},
     autocomplete: {},
+    altAction: {},
+    order: {},
     name: {},
-    value: {},
-    options: {},
+    label: { type: [String, Function] },
+    description: { type: [String, Function] },
+    hint: { type: [String, Function] },
+    placeholder: { type: [String, Function] },
+    optional: { type: [Boolean, Function] },
+    disabled: { type: [Boolean, Function] },
+    hidden: { type: [Boolean, Function] },
+    classes: { type: [String, Object, Function] },
+    styles: { type: [String, Object, Function] },
+    options: { type: [Array, Function] },
     attrs: {},
-    optional: { type: Boolean },
-    disabled: { type: Boolean },
-    hidden: { type: Boolean },
-    length: {},
-    validators: {}
+    value: {},
+    validators: {},
+    maxLength: {},
+    minLength: {},
+    min: {},
+    max: {},
+    error: {}
   },
   setup(n) {
-    const r = n, o = O(
+    const t = n, o = P(
       "vuiless"
-    ), t = i(
-      () => ({
-        v: o.value.formData[r.field],
-        data: o == null ? void 0 : o.value.formData,
-        context: o == null ? void 0 : o.value.formContext,
-        entry: r
-      })
-    ), m = i(() => C(r.label, t.value)), d = i(() => C(r.description, t.value)), b = i(() => C(r.hint, t.value)), v = i(() => C(r.placeholder, t.value)), y = i(() => C(r.optional, t.value)), l = i(() => C(r.disabled, t.value)), c = i(() => C(r.hidden, t.value)), s = i(() => C(r.options, t.value)), a = i(() => {
-      const u = S(r.classes, t.value);
-      return typeof u == "string" ? {
-        [u]: !0,
-        disabled: l.value,
-        // error: !validation.value.passed,
-        required: !y.value
+    ), r = m(() => ({
+      v: o.value.formData[t.field],
+      data: o.value.formData,
+      context: o.value.formContext ?? {}
+    })), a = m(() => b(t.optional, r.value)), d = m(() => b(t.disabled, r.value)), v = m(() => b(t.hidden, r.value)), f = m(() => ({
+      ...r.value,
+      entry: {
+        field: t.field,
+        type: t.type,
+        component: t.component,
+        name: t.name || t.field,
+        disabled: d.value,
+        optional: a.value,
+        hidden: v.value
+      }
+    })), g = m(() => b(t.label, f.value)), V = m(() => b(t.description, f.value)), i = m(() => b(t.hint, f.value)), s = m(() => b(t.placeholder, f.value)), c = m(() => b(t.options, f.value)), l = m(() => {
+      const C = b(t.classes, f.value);
+      return typeof C == "string" ? {
+        [C]: !0,
+        disabled: d.value,
+        required: !a.value
       } : {
-        ...u || {},
-        disabled: l.value,
-        // error: !validation.value.passed,
-        required: !y.value
+        ...C || {},
+        disabled: d.value,
+        required: !a.value
       };
-    }), e = i(
-      () => S(r.styles, t.value)
-    ), f = i(() => S(r.attrs, t.value)), g = i(() => {
-      var u;
-      return (u = r.validators) == null ? void 0 : u.map(
-        (E) => (D, P, z) => E({
-          v: D,
-          data: P,
-          context: z,
-          entry: r
-        })
-      );
-    });
-    return (u, E) => (p(), B(x(ee), {
-      modelValue: x(o).formData[r.field],
-      "onUpdate:modelValue": E[0] || (E[0] = (D) => x(o).formData[r.field] = D),
-      rules: g.value
+    }), u = m(
+      () => b(t.styles, f.value)
+    ), y = m(() => ie(t.attrs, f.value)), e = m(() => t.validators.map(
+      (C) => (D, h, _) => C({
+        v: D,
+        data: h,
+        context: _ ?? {},
+        entry: f.value.entry
+      })
+    ));
+    return (C, D) => (x(), q(B(ce), {
+      modelValue: B(o).formData[t.field],
+      "onUpdate:modelValue": D[0] || (D[0] = (h) => B(o).formData[t.field] = h),
+      rules: e.value
     }, {
-      default: w((D) => [
-        _(u.$slots, "default", {
-          onBlur: D.onBlur,
-          error: D.error,
-          model: D.model,
-          formData: x(o).formData,
-          formContext: x(o).formContext,
-          label: m.value,
-          description: d.value,
-          hint: b.value,
-          placeholder: v.value,
+      default: O((h) => [
+        A(C.$slots, "default", {
+          onBlur: h.onBlur,
+          error: n.error || h.error,
+          model: h.model,
+          formData: B(o).formData,
+          formContext: B(o).formContext,
+          label: g.value,
+          description: V.value,
+          hint: i.value,
+          placeholder: s.value,
           classes: {
-            ...a.value,
-            error: !!D.error
+            ...l.value,
+            error: !!n.error || !!h.error
           },
-          styles: e.value,
-          optional: y.value,
-          disabled: l.value,
-          hidden: c.value,
-          type: u.type,
-          altAction: u.altAction,
-          component: u.component,
-          vName: u.name,
-          field: u.field,
-          options: s.value,
-          length: u.length,
-          required: !y.value,
-          autocomplete: u.autocomplete,
-          attrs: f.value
+          styles: u.value,
+          optional: a.value,
+          disabled: d.value,
+          hidden: v.value,
+          type: n.type,
+          altAction: n.altAction,
+          component: n.component,
+          vName: n.name,
+          field: n.field,
+          options: c.value,
+          maxLength: n.maxLength,
+          required: !a.value,
+          autocomplete: n.autocomplete,
+          attrs: y.value
         })
       ]),
       _: 3
     }, 8, ["modelValue", "rules"]));
   }
-}), re = { key: 0 }, ae = { key: 1 }, ne = { key: 0 }, le = ["onUpdate:modelValue", "onBlur", "placeholder", "autocomplete", "name", "type"], se = { class: "oo-error-slot" }, ue = { key: 4 }, ie = { key: 5 }, ce = ["disabled"], pe = /* @__PURE__ */ q({
+}), pe = { key: 0 }, fe = { key: 1 }, ve = { key: 0 }, he = ["onUpdate:modelValue", "onBlur", "placeholder", "autocomplete", "name", "type"], be = { class: "oo-error-slot" }, ge = { key: 4 }, ye = { key: 5 }, xe = ["disabled"], Ee = /* @__PURE__ */ T({
   __name: "oo-form",
   props: {
     form: {},
@@ -245,142 +261,358 @@ const ee = /* @__PURE__ */ q({
     formContext: {},
     firstValidation: {},
     components: {},
-    types: {}
+    types: {},
+    errors: {}
   },
-  emits: ["submit"],
-  setup(n, { emit: r }) {
-    const o = n, t = i(() => o.form.executable()), m = i(
-      () => ({
-        v: void 0,
-        data: b.value,
-        context: o.formContext,
-        entry: o
-      })
-    ), d = k({}), b = i(() => o.formData || d.value), v = i(
-      () => C(t.value.submit.disabled, m.value)
-    ), y = r;
-    return (l, c) => (p(), B(x(te), {
-      "first-validation": l.firstValidation,
-      onSubmit: c[0] || (c[0] = (s) => y("submit", s)),
-      "form-data": b.value,
-      "form-context": l.formContext
+  emits: ["submit", "action", "unsupported-action"],
+  setup(n, { emit: t }) {
+    const o = n, r = w({}), a = m(() => o.formData || r.value), d = m(() => ({
+      v: void 0,
+      data: a.value,
+      context: o.formContext ?? {}
+    })), v = m(() => b(o.form.title, d.value)), f = m(() => b(o.form.submit.text, d.value)), g = m(() => b(o.form.submit.disabled, d.value));
+    function V(s) {
+      se(o.form, s) ? i("action", s, a.value) : i("unsupported-action", s, a.value);
+    }
+    const i = t;
+    return (s, c) => (x(), q(B(me), {
+      "first-validation": n.firstValidation,
+      onSubmit: c[0] || (c[0] = (l) => i("submit", l)),
+      "form-data": a.value,
+      "form-context": n.formContext
     }, {
-      default: w((s) => [
-        _(l.$slots, "form.header", {
-          clearErrors: s.clearErrors,
-          reset: s.reset,
-          title: t.value.title,
-          formContext: l.formContext,
-          disabled: v.value
+      default: O((l) => [
+        A(s.$slots, "form.header", {
+          clearErrors: l.clearErrors,
+          reset: l.reset,
+          title: v.value,
+          formContext: n.formContext,
+          disabled: g.value
         }, () => [
-          t.value.title ? (p(), V("h2", re, h(t.value.title), 1)) : j("", !0)
+          v.value ? (x(), E("h2", pe, F(v.value), 1)) : H("", !0)
         ]),
-        _(l.$slots, "form.before", {
-          clearErrors: s.clearErrors,
-          reset: s.reset
+        A(s.$slots, "form.before", {
+          clearErrors: l.clearErrors,
+          reset: l.reset
         }),
-        (p(!0), V(K, null, Q(t.value.entries, (a) => (p(), B(oe, A(M(a)), {
-          default: w((e) => [
-            _(l.$slots, `field:${e.type}`, A(M(e)), () => {
-              var f, g, u;
-              return [
-                a.component && ((f = o.components) != null && f[a.component]) ? (p(), B(F(o.components[a.component]), H({
-                  key: 0,
-                  "on-blur": e.onBlur,
-                  error: e.error,
-                  model: e.model,
-                  "form-data": e.formData,
-                  "form-context": e.formContext,
-                  label: e.label,
-                  description: e.description,
-                  hint: e.hint,
-                  placeholder: e.placeholder,
-                  class: e.classes,
-                  style: e.styles,
-                  optional: e.optional,
-                  required: !e.required,
-                  disabled: e.disabled,
-                  hidden: e.hidden,
-                  type: e.type,
-                  "alt-action": e.altAction,
-                  name: e.vName,
-                  field: e,
-                  options: e.options,
-                  length: e.length,
-                  autocomplete: e.autocomplete
-                }, e.attrs), null, 16, ["on-blur", "error", "model", "form-data", "form-context", "label", "description", "hint", "placeholder", "class", "style", "optional", "required", "disabled", "hidden", "type", "alt-action", "name", "field", "options", "length", "autocomplete"])) : a.component && !((g = o.components) != null && g[a.component]) ? (p(), V("div", ae, " [" + h(e.label) + '] Component "' + h(e.component) + '" not supplied ', 1)) : (u = o.types) != null && u[a.type] ? (p(), B(F(o.types[a.type]), H({
-                  key: 2,
-                  "on-blur": e.onBlur,
-                  error: e.error,
-                  model: e.model,
-                  "form-data": e.formData,
-                  "form-context": e.formContext,
-                  label: e.label,
-                  description: e.description,
-                  hint: e.hint,
-                  placeholder: e.placeholder,
-                  class: e.classes,
-                  style: e.styles,
-                  optional: e.optional,
-                  required: !e.required,
-                  disabled: e.disabled,
-                  hidden: e.hidden,
-                  type: e.type,
-                  "alt-action": e.altAction,
-                  name: e.vName,
-                  field: e,
-                  options: e.options,
-                  length: e.length,
-                  autocomplete: e.autocomplete
-                }, e.attrs), null, 16, ["on-blur", "error", "model", "form-data", "form-context", "label", "description", "hint", "placeholder", "class", "style", "optional", "required", "disabled", "hidden", "type", "alt-action", "name", "field", "options", "length", "autocomplete"])) : ["text", "password", "number"].includes(e.type) ? (p(), V("div", {
-                  key: 3,
-                  class: X(["oo-default-field", e.classes])
-                }, [
-                  $("label", null, h(e.label), 1),
-                  e.description ? (p(), V("span", ne, h(e.description), 1)) : j("", !0),
-                  Y($("input", {
-                    "onUpdate:modelValue": (E) => e.model.value = E,
-                    onBlur: e.onBlur,
+        (x(!0), E(te, null, oe(o.form.fields, (u) => {
+          var y;
+          return x(), q(de, $({
+            key: u.field
+          }, { ref_for: !0 }, u, {
+            error: (y = n.errors) == null ? void 0 : y[u.field]
+          }), {
+            default: O((e) => [
+              A(s.$slots, `field:${e.type}`, $({ ref_for: !0 }, e), () => {
+                var C, D, h;
+                return [
+                  u.component && ((C = o.components) != null && C[u.component]) ? (x(), q(z(o.components[u.component]), $({
+                    key: 0,
+                    "on-blur": e.onBlur,
+                    error: e.error,
+                    model: e.model,
+                    "form-data": e.formData,
+                    "form-context": e.formContext,
+                    label: e.label,
+                    description: e.description,
+                    hint: e.hint,
                     placeholder: e.placeholder,
+                    class: e.classes,
+                    style: e.styles,
+                    optional: e.optional,
+                    required: !e.required,
+                    disabled: e.disabled,
+                    hidden: e.hidden,
+                    type: e.type,
+                    "alt-action": e.altAction,
+                    name: e.vName,
+                    field: e,
+                    options: e.options,
+                    "max-length": e.maxLength,
                     autocomplete: e.autocomplete,
+                    onAction: V
+                  }, { ref_for: !0 }, e.attrs, {
+                    modelValue: e.model.value,
+                    "onUpdate:modelValue": (_) => e.model.value = _
+                  }), null, 16, ["on-blur", "error", "model", "form-data", "form-context", "label", "description", "hint", "placeholder", "class", "style", "optional", "required", "disabled", "hidden", "type", "alt-action", "name", "field", "options", "max-length", "autocomplete", "modelValue", "onUpdate:modelValue"])) : u.component && !((D = o.components) != null && D[u.component]) ? (x(), E("div", fe, " [" + F(e.label) + '] Component "' + F(e.component) + '" not supplied ', 1)) : (h = o.types) != null && h[u.type] ? (x(), q(z(o.types[u.type]), $({
+                    key: 2,
+                    "on-blur": e.onBlur,
+                    error: e.error,
+                    model: e.model,
+                    "form-data": e.formData,
+                    "form-context": e.formContext,
+                    label: e.label,
+                    description: e.description,
+                    hint: e.hint,
+                    placeholder: e.placeholder,
+                    class: e.classes,
+                    style: e.styles,
+                    optional: e.optional,
+                    required: !e.required,
+                    disabled: e.disabled,
+                    hidden: e.hidden,
+                    type: e.type,
+                    "alt-action": e.altAction,
                     name: e.vName,
-                    type: e.type
-                  }, null, 40, le), [
-                    [Z, e.model.value]
-                  ]),
-                  $("div", se, h(e.error || e.hint), 1)
-                ], 2)) : e.type === "paragraph" ? (p(), V("p", ue, h(e.description), 1)) : (p(), V("div", ie, " [" + h(e.label) + '] Not supported field type "' + h(e.type) + '" ' + h(e.component), 1))
-              ];
-            })
-          ]),
-          _: 2
-        }, 1040))), 256)),
-        _(l.$slots, "form.after", {
-          clearErrors: s.clearErrors,
-          reset: s.reset,
-          disabled: v.value,
-          formContext: l.formContext
+                    field: e,
+                    options: e.options,
+                    "max-length": e.maxLength,
+                    autocomplete: e.autocomplete,
+                    onAction: V
+                  }, { ref_for: !0 }, e.attrs, {
+                    modelValue: e.model.value,
+                    "onUpdate:modelValue": (_) => e.model.value = _
+                  }), null, 16, ["on-blur", "error", "model", "form-data", "form-context", "label", "description", "hint", "placeholder", "class", "style", "optional", "required", "disabled", "hidden", "type", "alt-action", "name", "field", "options", "max-length", "autocomplete", "modelValue", "onUpdate:modelValue"])) : ["text", "password", "number"].includes(e.type) ? (x(), E("div", {
+                    key: 3,
+                    class: ne(["oo-default-field", e.classes])
+                  }, [
+                    M("label", null, F(e.label), 1),
+                    e.description ? (x(), E("span", ve, F(e.description), 1)) : H("", !0),
+                    le(M("input", {
+                      "onUpdate:modelValue": (_) => e.model.value = _,
+                      onBlur: e.onBlur,
+                      placeholder: e.placeholder,
+                      autocomplete: e.autocomplete,
+                      name: e.vName,
+                      type: e.type
+                    }, null, 40, he), [
+                      [re, e.model.value]
+                    ]),
+                    M("div", be, F(e.error || e.hint), 1)
+                  ], 2)) : e.type === "paragraph" ? (x(), E("p", ge, F(e.description), 1)) : (x(), E("div", ye, " [" + F(e.label) + '] Not supported field type "' + F(e.type) + '" ' + F(e.component), 1))
+                ];
+              })
+            ]),
+            _: 2
+          }, 1040, ["error"]);
+        }), 128)),
+        A(s.$slots, "form.after", {
+          clearErrors: l.clearErrors,
+          reset: l.reset,
+          disabled: g.value,
+          formContext: n.formContext
         }),
-        _(l.$slots, "form.submit", {
-          disabled: v.value,
-          clearErrors: s.clearErrors,
-          reset: s.reset,
-          formContext: l.formContext
+        A(s.$slots, "form.submit", {
+          disabled: g.value,
+          text: f.value,
+          clearErrors: l.clearErrors,
+          reset: l.reset,
+          formContext: n.formContext
         }, () => [
-          $("button", { disabled: v.value }, h(t.value.submit.text), 9, ce)
+          M("button", { disabled: g.value }, F(f.value), 9, xe)
         ]),
-        _(l.$slots, "form.footer", {
-          disabled: v.value,
-          clearErrors: s.clearErrors,
-          reset: s.reset,
-          formContext: l.formContext
+        A(s.$slots, "form.footer", {
+          disabled: g.value,
+          clearErrors: l.clearErrors,
+          reset: l.reset,
+          formContext: n.formContext
         })
       ]),
       _: 3
     }, 8, ["first-validation", "form-data", "form-context"]));
   }
-});
+}), Ce = {
+  // Node.js Globals
+  global: null,
+  process: null,
+  Buffer: null,
+  require: null,
+  __filename: null,
+  __dirname: null,
+  exports: null,
+  module: null,
+  setImmediate: null,
+  clearImmediate: null,
+  setTimeout: null,
+  clearTimeout: null,
+  setInterval: null,
+  clearInterval: null,
+  queueMicrotask: null,
+  queueGlobalMicrotask: null,
+  globalThis: null,
+  // GlobalThis (Introduced in ECMAScript 2020)
+  // Browser Globals
+  window: null,
+  self: null,
+  document: null,
+  localStorage: null,
+  sessionStorage: null,
+  indexedDB: null,
+  caches: null,
+  console: null,
+  performance: null,
+  fetch: null,
+  XMLHttpRequest: null,
+  Image: null,
+  Audio: null,
+  navigator: null,
+  navigation: null,
+  location: null,
+  history: null,
+  screen: null,
+  requestAnimationFrame: null,
+  cancelAnimationFrame: null,
+  cancelIdleCallback: null,
+  captureEvents: null,
+  chrome: null,
+  clientInformation: null,
+  addEventListener: null,
+  removeEventListener: null,
+  blur: null,
+  close: null,
+  closed: null,
+  confirm: null,
+  alert: null,
+  customElements: null,
+  dispatchEvent: null,
+  debug: null,
+  focus: null,
+  find: null,
+  frames: null,
+  getSelection: null,
+  getScreenDetails: null,
+  getEventListeners: null,
+  keys: null,
+  launchQueue: null,
+  parent: null,
+  postMessage: null,
+  print: null,
+  profile: null,
+  profileEnd: null,
+  prompt: null,
+  queryLocalFonts: null,
+  queryObjects: null,
+  releaseEvents: null,
+  reportError: null,
+  resizeBy: null,
+  resizeTo: null,
+  scheduler: null,
+  stop: null,
+  scroll: null,
+  scrollBy: null,
+  scrollTo: null,
+  scrollY: null,
+  scrollX: null,
+  top: null,
+  // other
+  eval: null,
+  __ctx__: null
+};
+class _e {
+  constructor() {
+    N(this, "cache", /* @__PURE__ */ new Map());
+  }
+  call(t, o) {
+    return this.getFn(t)(o);
+  }
+  getFn(t) {
+    let o = this.cache.get(t);
+    return o || (o = Ve(t), this.cache.set(t, o)), o;
+  }
+}
+function Ve(n) {
+  const t = `with(__ctx__){
+${n}
+}`, o = new Function("__ctx__", t);
+  return (r) => {
+    const a = Object.freeze(Object.assign({}, Ce, r));
+    return o(a);
+  };
+}
+const j = new _e();
+function S(n) {
+  const t = `return (${n})(v, data, context, entry)`;
+  return j.getFn(t);
+}
+function I(n) {
+  const t = `return (${n})(data, context)`;
+  return j.getFn(t);
+}
+function Fe(n) {
+  const t = `return (${n})(v, data, context)`;
+  return j.getFn(t);
+}
+function k(n, t, o, r, a) {
+  const d = o.get(t);
+  if (typeof d == "string")
+    return r(d);
+  const v = o.get(n);
+  return v !== void 0 ? v : a;
+}
+function Se(n) {
+  var t, o, r;
+  const a = n.metadata, d = n.type.props, v = k("foorm.title", "foorm.fn.title", a, I, ""), f = k("foorm.submit.text", "foorm.fn.submit.text", a, I, "Submit"), g = (() => {
+    const s = a.get("foorm.fn.submit.disabled");
+    return typeof s == "string" ? I(s) : !1;
+  })(), V = { text: f, disabled: g }, i = [];
+  for (const [s, c] of d.entries()) {
+    const l = c.metadata, u = (t = c.type) === null || t === void 0 ? void 0 : t.tags, y = l.get("foorm.type"), e = (o = u == null ? void 0 : u.has("action")) !== null && o !== void 0 ? o : !1, C = (r = u == null ? void 0 : u.has("paragraph")) !== null && r !== void 0 ? r : !1, D = y ?? (e ? "action" : C ? "paragraph" : "text"), h = [], _ = l.get("foorm.validate");
+    if (_) {
+      const p = Array.isArray(_) ? _ : [_];
+      for (const L of p)
+        typeof L == "string" && h.push(Fe(L));
+    }
+    const G = {
+      field: s,
+      type: D,
+      component: l.get("foorm.component"),
+      autocomplete: l.get("foorm.autocomplete"),
+      altAction: l.get("foorm.altAction"),
+      order: l.get("foorm.order"),
+      name: s,
+      label: k("meta.label", "foorm.fn.label", l, S, s),
+      description: k("meta.description", "foorm.fn.description", l, S, ""),
+      hint: k("meta.hint", "foorm.fn.hint", l, S, ""),
+      placeholder: k("meta.placeholder", "foorm.fn.placeholder", l, S, ""),
+      optional: (() => {
+        var p;
+        const L = l.get("foorm.fn.optional");
+        return typeof L == "string" ? S(L) : (p = c.optional) !== null && p !== void 0 ? p : !1;
+      })(),
+      disabled: (() => {
+        const p = l.get("foorm.fn.disabled");
+        return typeof p == "string" ? S(p) : l.get("foorm.disabled") !== void 0;
+      })(),
+      hidden: (() => {
+        const p = l.get("foorm.fn.hidden");
+        return typeof p == "string" ? S(p) : l.get("foorm.hidden") !== void 0;
+      })(),
+      classes: (() => {
+        const p = l.get("foorm.fn.classes");
+        if (typeof p == "string")
+          return S(p);
+      })(),
+      styles: (() => {
+        const p = l.get("foorm.fn.styles");
+        if (typeof p == "string")
+          return S(p);
+      })(),
+      options: (() => {
+        const p = l.get("foorm.fn.options");
+        if (typeof p == "string")
+          return S(p);
+      })(),
+      value: l.get("foorm.value"),
+      validators: h,
+      // ATScript @expect constraints
+      maxLength: l.get("expect.maxLength"),
+      minLength: l.get("expect.minLength"),
+      min: l.get("expect.min"),
+      max: l.get("expect.max")
+    };
+    i.push(G);
+  }
+  return i.sort((s, c) => {
+    var l, u;
+    return ((l = s.order) !== null && l !== void 0 ? l : 1 / 0) - ((u = c.order) !== null && u !== void 0 ? u : 1 / 0);
+  }), { title: v, submit: V, fields: i };
+}
+function Be(n) {
+  const t = Se(n), o = ae(ue(t.fields));
+  return { form: t, formData: o };
+}
 export {
-  oe as OoField,
-  pe as OoForm
+  de as OoField,
+  Ee as OoForm,
+  Be as useFoorm
 };