@myparcel-dev/vue-form-builder 1.0.0-beta.44

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { AnyElementConfiguration, AnyElementInstance, ComponentOrHtmlElement, ComponentProps, CreatedElement, CreatedField, CreatedForm, ElementName, FormConfiguration, FormInstance, InteractiveElementConfiguration, InteractiveElementInstance, ModularCreatedElement, ModularCreatedField, PlainElementConfiguration, PlainElementInstance, ResolvedElementConfiguration, Validator, } from '@myparcel-vfb/core';
+export type { SelectOption } from '@myparcel-vfb/utils';
+export { FormHook, MagicForm, createField, createForm, defineField, defineForm, useElement, useForm, useFormBuilder, } from '@myparcel-vfb/core';
+export { MyParcelFormBuilderPlugin, createMyParcelFormBuilderPlugin } from '@myparcel-vfb/plugin';

package/dist/index.js

@@ -0,0 +1,619 @@
+var le = Object.defineProperty;
+var ue = (s, t, e) => t in s ? le(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var n = (s, t, e) => (ue(s, typeof t != "symbol" ? t + "" : t, e), e);
+import * as he from "vue";
+import { inject as K, defineComponent as y, toRefs as q, computed as b, unref as v, openBlock as m, createBlock as w, resolveDynamicComponent as T, mergeProps as G, createSlots as fe, renderList as B, withCtx as k, renderSlot as O, normalizeProps as de, guardReactiveProps as ce, provide as J, h as g, Teleport as me, reactive as C, markRaw as F, ref as f, onMounted as Y, onUnmounted as pe, defineAsyncComponent as be, toValue as o, createElementBlock as A, Fragment as _, Suspense as Q, createCommentVNode as W, withModifiers as L, createVNode as ve, watchEffect as we, watch as H } from "vue";
+import { isOfType as p, asyncEvery as ye } from "@myparcel/ts-utils";
+import { useMemoize as ke, isDefined as Ee } from "@vueuse/core";
+const ge = (s) => p(s, "then") ? s : Promise.resolve(s), z = (s) => s.charAt(0).toUpperCase() + s.slice(1), Ve = (s, t) => {
+  const e = [t];
+  if (t.startsWith("before")) {
+    const r = t.replace(/^before/, "").toLowerCase();
+    e.push(r), e.push(`after${z(r)}`);
+  }
+  if (t.startsWith("after")) {
+    const r = t.replace(/^after/, "").toLowerCase();
+    e.push(r), e.push(`before${z(r)}`);
+  }
+  return e.some((r) => s.includes(r));
+};
+class X {
+  constructor(t) {
+    n(this, "availableHooks");
+    n(this, "registeredHooks", []);
+    this.availableHooks = t.hookNames ?? [], Object.keys(t).filter((e) => Ve(this.availableHooks, e)).forEach((e) => {
+      this.register(e, t[e]);
+    });
+  }
+  getAvailableHooks() {
+    return this.availableHooks;
+  }
+  getRegisteredHooks() {
+    return this.registeredHooks;
+  }
+  async execute(t, ...e) {
+    const r = await Promise.all(
+      this.registeredHooks.filter((i) => i.name === t).map((i) => i.callback(...e))
+    );
+    return r[r.length - 1];
+  }
+  has(t, e) {
+    return this.registeredHooks.some((r) => r.name === t && (e == null ? void 0 : e(r)));
+  }
+  register(t, e) {
+    const r = () => this.unregister(t, e);
+    return this.has(t, (i) => this.callbackMatches(i, e)) || this.registeredHooks.push({ name: t, callback: e }), r;
+  }
+  unregister(t, e) {
+    const r = () => this.registeredHooks.findIndex((a) => a.name === t && (!e || this.callbackMatches(a, e)));
+    let i;
+    for (; (i = r()) > -1; )
+      this.registeredHooks.splice(i, 1);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  callbackMatches(t, e) {
+    return t.callback.toString() === e.toString();
+  }
+}
+const Z = (s) => new X(s), Oe = () => ({
+  field: {
+    elementProp: !0
+  },
+  fieldDefaults: {
+    attributes: {},
+    wrapper: !0
+  },
+  fields: [],
+  form: {
+    attributes: {},
+    tag: "form"
+  }
+});
+var c = /* @__PURE__ */ ((s) => (s.BeforeValidate = "beforeValidate", s.AfterValidate = "afterValidate", s.BeforeSubmit = "beforeSubmit", s.AfterSubmit = "afterSubmit", s.BeforeReset = "beforeReset", s.AfterReset = "afterReset", s.ElementChange = "afterElementChange", s.BeforeAddElement = "beforeAddElement", s.AfterAddElement = "afterAddElement", s))(c || {});
+const ee = Object.freeze(Object.values(c)), x = [
+  "onCreated",
+  "onActivated",
+  "onBeforeMount",
+  "onBeforeUnmount",
+  "onBeforeUpdate",
+  "onDeactivated",
+  "onMounted",
+  "onUnmounted",
+  "onUpdated"
+], te = ["blur", "click", "focus", ...x], Fe = [
+  "blur",
+  "focus",
+  "sanitize",
+  "update",
+  "validate",
+  ...te
+], P = "onCreated", se = () => ({
+  hooks: x,
+  register(s, ...t) {
+    s.has(P) && s.execute(P, ...t), s.getRegisteredHooks().filter(
+      (e) => x.includes(e.name) && e.name !== P
+    ).forEach((e) => {
+      he[e.name](async () => {
+        await s.execute(e.name, ...t);
+      });
+    });
+  }
+}), De = (s) => {
+  se().register(s.hooks, s);
+}, re = Symbol("form"), ie = Symbol("element"), Je = () => {
+  const s = K(ie);
+  if (!s)
+    throw new Error("No element found.");
+  return s;
+}, M = () => {
+  const s = K(re);
+  if (!s)
+    throw new Error("No form found.");
+  return s;
+}, Re = /* @__PURE__ */ y({
+  __name: "FormElement",
+  props: {
+    element: {}
+  },
+  setup(s) {
+    const t = s, e = q(t);
+    De(e.element.value);
+    const r = b(() => {
+      var h, l;
+      const a = (l = (h = t.element.form) == null ? void 0 : h.config.field) == null ? void 0 : l.elementProp, u = {
+        ...t.element.attributes
+      };
+      return typeof t.element.component != "string" && a !== !1 && (u.element = t.element), u;
+    }), i = b({
+      get() {
+        return v(t.element.ref);
+      },
+      set(a) {
+        t.element.ref = a;
+      }
+    });
+    return (a, u) => (m(), w(T(a.element.component), G({
+      modelValue: i.value,
+      "onUpdate:modelValue": u[0] || (u[0] = (h) => i.value = h)
+    }, r.value), fe({ _: 2 }, [
+      B(Object.keys(a.$slots), (h) => ({
+        name: h,
+        fn: k((l) => [
+          O(a.$slots, h, de(ce(l || {})))
+        ])
+      }))
+    ]), 1040, ["modelValue"]));
+  }
+}), $e = (s) => {
+  const t = [];
+  let e = {};
+  return p(s, "children") && (Array.isArray(s.children) ? s.children.forEach((r) => {
+    t.push(typeof r == "function" ? r : () => r);
+  }) : p(s, "children") ? e = s.children : t.push(s.children)), { ...t, ...e };
+}, N = y({
+  name: "FormElementWrapper",
+  props: {
+    form: {
+      type: Object,
+      required: !0
+    },
+    element: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(s) {
+    J(ie, s.element);
+  },
+  render() {
+    var i, a, u;
+    const s = $e(this.element.component);
+    let t = g(
+      Re,
+      {
+        ...this.$attrs,
+        ...ze(this.element),
+        element: this.element
+      },
+      {
+        ...s,
+        ...this.element.slots,
+        ...this.$slots
+      }
+    );
+    const e = typeof this.element.wrapper != "boolean";
+    if (this.element.wrapper === !0 && ((i = this.form.config.field) == null ? void 0 : i.wrapper) || e) {
+      const h = t;
+      t = g(
+        e ? this.element.wrapper : (a = this.form.config.field) == null ? void 0 : a.wrapper,
+        {
+          ...this.$attrs,
+          ...(u = this.form.config.fieldDefaults) == null ? void 0 : u.attributes,
+          element: this.element
+        },
+        { ...this.element.slots, default: () => h }
+      );
+    }
+    return this.element.teleportSelector ? g(me, { to: this.element.teleportSelector }, [t]) : t;
+  }
+}), Ce = (s) => y({
+  setup() {
+    const t = M(), e = f();
+    return Y(async () => {
+      e.value = await t.addElement(s);
+    }), pe(() => {
+      e.value && (t.removeElement(e.value.name), e.value = void 0);
+    }), {
+      element: e,
+      form: t
+    };
+  },
+  render() {
+    return this.element && g(N, { ...this.$attrs, form: this.form, element: this.element }, this.$slots);
+  }
+}), Me = (s) => y({
+  setup() {
+    const t = M();
+    return { element: b(() => s.name && t.getField(s.name)) };
+  },
+  render() {
+    return this.element && g("label", { for: this.element.attributes.id ?? this.element.name }, [this.element.label]);
+  }
+}), Se = (s) => y({
+  setup() {
+    const t = M();
+    return { element: b(() => s.name ? t.getField(s.name) : void 0) };
+  },
+  render() {
+    var t, e, r;
+    return o((t = this.element) == null ? void 0 : t.errors) && ((r = (e = this.$slots).default) == null ? void 0 : r.call(e, { errors: o(this.element.errors) }));
+  }
+}), j = (s) => F(be(() => Promise.resolve(s()))), Ye = (s) => C({
+  field: s,
+  Component: F(Ce(s)),
+  ...p(s, "ref") && {
+    ref: s.ref ?? f(),
+    Label: j(() => Me(s)),
+    Errors: j(() => Se(s))
+  }
+}), Ae = /* @__PURE__ */ y({
+  __name: "RenderedFormContent",
+  setup(s) {
+    const t = f(!1), e = M();
+    if (!e)
+      throw new Error("Form not found");
+    const r = b(() => o(e.fields).filter((a) => !a.teleportSelector)), i = b(() => o(e.fields).filter((a) => !!a.teleportSelector));
+    return (a, u) => (m(), A(_, null, [
+      v(e) ? (m(), w(Q, {
+        key: 0,
+        onResolve: u[0] || (u[0] = (h) => t.value = !0)
+      }, {
+        default: k(() => [
+          (m(!0), A(_, null, B(r.value, (h, l) => (m(), w(v(N), {
+            key: `element--${h.name ?? "unnamed"}--${l}`,
+            element: h,
+            form: v(e)
+          }, null, 8, ["element", "form"]))), 128))
+        ]),
+        _: 1
+      })) : W("", !0),
+      v(e) && t.value ? (m(!0), A(_, { key: 1 }, B(i.value, (h, l) => (m(), w(v(N), {
+        key: `element--${h.name ?? "unnamed"}--${l}`,
+        element: h,
+        form: v(e)
+      }, null, 8, ["element", "form"]))), 128)) : W("", !0)
+    ], 64));
+  }
+}), _e = y({
+  name: "Fragment",
+  props: {
+    component: {
+      type: [String, Object],
+      default: null
+    }
+  }
+}), Pe = (s, t) => {
+  const e = s.__vccOpts || s;
+  for (const [r, i] of t)
+    e[r] = i;
+  return e;
+};
+function Be(s, t, e, r, i, a) {
+  return s.component ? (m(), w(T(s.component), { key: 0 }, {
+    default: k(() => [
+      O(s.$slots, "default")
+    ]),
+    _: 3
+  })) : O(s.$slots, "default", { key: 1 });
+}
+const He = /* @__PURE__ */ Pe(_e, [["render", Be]]), xe = /* @__PURE__ */ y({
+  __name: "MagicForm",
+  props: {
+    form: {}
+  },
+  setup(s, { emit: t }) {
+    const e = f(null), r = s, i = t, u = q(r).form.value;
+    return Y(() => {
+      const l = o(e);
+      l && (r.form.element = l);
+    }), J(re, u), ee.forEach((l) => {
+      r.form.on(l, (d) => {
+        i(l, d);
+      });
+    }), se().register(u.hooks, u), (l, d) => (m(), w(T(l.form.config.form.tag), G({
+      id: l.form.name,
+      ref_key: "formElement",
+      ref: e
+    }, l.form.config.form.attributes, {
+      onSubmit: d[0] || (d[0] = L(() => l.form.submit(), ["prevent"])),
+      onReset: d[1] || (d[1] = L(() => l.form.reset(), ["prevent"]))
+    }), {
+      default: k(() => [
+        ve(He, {
+          component: l.form.config.form.wrapper
+        }, {
+          default: k(() => [
+            l.$slots.default ? (m(), w(Q, { key: 0 }, {
+              default: k(() => [
+                O(l.$slots, "default")
+              ]),
+              fallback: k(() => [
+                O(l.$slots, "loader")
+              ]),
+              _: 3
+            })) : (m(), w(Ae, { key: 1 }))
+          ]),
+          _: 3
+        }, 8, ["component"])
+      ]),
+      _: 3
+    }, 16, ["id"]));
+  }
+}), Ne = (s, t) => ne().register(s, t), Qe = (s, t) => {
+  const e = Ne(s, t);
+  return {
+    Component: F((r, i) => g(xe, { ...i.attrs, form: e }, i.slots)),
+    instance: e
+  };
+}, Xe = (s) => s, E = (s) => {
+  if (typeof s == "string" || typeof s == "boolean")
+    return s;
+  if (s)
+    return F(s);
+}, $ = (s, t) => {
+  s && we(() => {
+    ge(s()).then((e) => {
+      t.value = e;
+    });
+  });
+};
+class oe {
+  constructor(t, e) {
+    n(this, "errors", f([]));
+    n(this, "attributes");
+    n(this, "component");
+    n(this, "form");
+    n(this, "formattedErrors");
+    n(this, "isVisible", f(!0));
+    n(this, "name");
+    n(this, "props");
+    n(this, "wrapper");
+    n(this, "config");
+    this.hooks = Z({
+      ...e,
+      hookNames: [...te, ...e.hookNames ?? []]
+    });
+    const r = this.hooks.getAvailableHooks();
+    if (Object.keys(e).filter((i) => !r.includes(i)).forEach((i) => {
+      this[i] = e[i];
+    }), this.props = C(e.props ?? {}), this.attributes = C(e.attributes ?? {}), this.config = e, this.form = t, this.name = e.name, this.wrapper = e.wrapper ?? !0, this.setVisible(e.visible ?? !0), this.formattedErrors = b(() => o(this.errors).map((i) => typeof i == "function" ? i() : i)), "visibleWhen" in e && $(() => this.config.visibleWhen(this), this.isVisible), typeof e.component == "string") {
+      this.component = e.component;
+      return;
+    }
+    this.component = F(e.component);
+  }
+  setVisible(t) {
+    this.isVisible.value = t;
+  }
+  resetValidation() {
+    this.errors.value = [];
+  }
+}
+const Te = (s) => ({
+  validate: (t, e) => !(e == null || e === ""),
+  errorMessage: s
+});
+class Ie extends oe {
+  // eslint-disable-next-line max-lines-per-function
+  constructor(e, r) {
+    var i, a, u;
+    super(e, { ...r, hookNames: Fe });
+    n(this, "errorsTarget");
+    n(this, "isDirty", f(!1));
+    n(this, "isDisabled", f(!1));
+    n(this, "isOptional", f(!1));
+    n(this, "isReadOnly", f(!1));
+    n(this, "isSuspended", f(!1));
+    n(this, "isTouched", f(!1));
+    n(this, "isValid", f(!0));
+    n(this, "label");
+    n(this, "lazy", !1);
+    n(this, "ref");
+    n(this, "validators", f([]));
+    n(this, "initialValue");
+    n(this, "blur", async () => {
+      await this.hooks.execute("beforeBlur", this, o(this.ref)), this.isSuspended.value = !0, this.ref.value = await this.hooks.execute("sanitize", this, o(this.ref)) ?? o(this.ref), o(this.isDirty) && await this.validate(), this.isTouched.value = !0, this.isSuspended.value = !1, await this.hooks.execute("afterBlur", this, o(this.ref));
+    });
+    n(this, "focus", async (e, r) => {
+      await this.hooks.execute("beforeFocus", this, r), await this.hooks.execute("focus", this, r), await this.hooks.execute("afterFocus", this, r);
+    });
+    n(this, "reset", () => {
+      this.resetValidation(), this.isDirty.value = !1, this.isTouched.value = !1, this.ref.value = this.initialValue;
+    });
+    n(this, "validate", async () => {
+      var h;
+      if (this.resetValidation(), await this.hooks.execute("beforeValidate", this, o(this.ref)), o(this.isDisabled))
+        return this.isValid.value = !0, o(this.isValid);
+      const e = async (l) => {
+        var I;
+        const d = await l.validate(this, o(this.ref));
+        if (!d && l.errorMessage)
+          if (this.errorsTarget) {
+            const S = o(this.form.fields).find(
+              (ae) => ae.name === this.errorsTarget
+            );
+            (I = o(S == null ? void 0 : S.errors)) == null || I.push(l.errorMessage);
+          } else
+            o(this.errors).push(l.errorMessage);
+        return d;
+      }, r = o(this.validators).filter((l) => !l.precedence), i = o(this.validators).filter((l) => p(l, "precedence")).sort((l, d) => (l.precedence ?? 0) - (d.precedence ?? 0));
+      o(this.isOptional) || r.push(Te(((h = this.form.config.validationMessages) == null ? void 0 : h.required) ?? ""));
+      const a = (await Promise.all(r.map(e))).every(Boolean), u = await ye(i, e);
+      return this.isValid.value = a && u, await this.hooks.execute("afterValidate", this, o(this.ref), o(this.isValid)), o(this.isValid);
+    });
+    this.ref = r.ref, (i = e.config.initialValues) != null && i.hasOwnProperty(r.name) && (this.ref.value = e.config.initialValues[r.name]), this.initialValue = o(this.ref), this.lazy = r.lazy ?? !1, this.errorsTarget = r.errorsTarget, this.label = r.label ? ((u = (a = e.config).renderLabel) == null ? void 0 : u.call(a, r.label)) ?? r.label : void 0, this.isDisabled.value = r.disabled ?? !1, this.isOptional.value = r.optional ?? !1, this.isReadOnly.value = r.readOnly ?? !1, this.createValidators(r), H(this.ref, async (h, l) => {
+      await this.hooks.execute("beforeUpdate", this, h, l), this.isDirty.value = !0, await this.hooks.execute("afterUpdate", this, h, l);
+    }), H(e.stable, (h) => {
+      h && (r.disabledWhen && $(() => r.disabledWhen(this), this.isDisabled), r.optionalWhen && $(() => r.optionalWhen(this), this.isOptional), r.readOnlyWhen && $(() => r.readOnlyWhen(this), this.isReadOnly));
+    });
+  }
+  setDisabled(e) {
+    this.isDisabled.value = e;
+  }
+  setOptional(e) {
+    this.isOptional.value = e;
+  }
+  setReadOnly(e) {
+    this.isReadOnly.value = e;
+  }
+  createValidators(e) {
+    let r = [];
+    p(e, "validate") && (r = [
+      {
+        validate: e.validate,
+        errorMessage: e.errorMessage
+      }
+    ]), p(e, "validators") && (r = e.validators ?? []), this.validators.value = r;
+  }
+}
+class We {
+  constructor(t, e) {
+    n(this, "config");
+    n(this, "fields", f([]));
+    n(this, "hooks");
+    n(this, "interactiveFields");
+    n(this, "isDirty");
+    n(this, "isValid", f(!0));
+    n(this, "model", {});
+    n(this, "name");
+    n(this, "off");
+    n(this, "on");
+    n(this, "stable", f(!1));
+    n(this, "values");
+    n(this, "getFieldMemoized", ke((t) => o(this.fields).find((r) => r.name === t) ?? null));
+    const { fields: r, ...i } = e;
+    e.hookNames = [...ee, ...e.hookNames ?? []], this.hooks = Z(e), this.on = this.hooks.register.bind(this.hooks), this.off = this.hooks.unregister.bind(this.hooks), this.name = t, this.config = i, this.values = C({}), E(this.config.field.wrapper), E(this.config.fieldDefaults.wrapper), r.forEach((a) => {
+      const u = this.createFieldInstance(a, this);
+      o(this.fields).push(u);
+    }), this.interactiveFields = b(() => o(this.fields).filter((a) => p(a, "ref"))), this.isDirty = b(() => o(this.interactiveFields).some((a) => o(a.isDirty))), this.stable.value = !0;
+  }
+  async addElement(t, e, r = "after") {
+    await this.hooks.execute(c.BeforeAddElement, this, t);
+    const i = e ? o(this.fields).findIndex((h) => h.name === e) : o(this.fields).length;
+    if (e && i === -1) {
+      console.error(`Field ${e} not found in form ${this.name}`);
+      return;
+    }
+    const a = r === "after" ? i + 1 : i, u = this.createFieldInstance(t, this);
+    return o(this.fields).splice(a, 0, u), await this.hooks.execute(c.AfterAddElement, this, t), u;
+  }
+  getField(t) {
+    return this.getFieldMemoized(t);
+  }
+  getValue(t) {
+    const e = this.ensureGetField(t);
+    return o(e.ref);
+  }
+  getValues() {
+    return o(this.values);
+  }
+  removeElement(t) {
+    const e = o(this.fields).findIndex((r) => r.name === t);
+    o(this.fields).splice(e, 1), this.getFieldMemoized.delete(t);
+  }
+  async reset() {
+    await this.hooks.execute(c.BeforeReset, this), await Promise.all(o(this.interactiveFields).map((t) => t.reset())), await this.hooks.execute(c.AfterReset, this);
+  }
+  setValue(t, e) {
+    const r = this.getField(t);
+    r && (r.ref.value = e);
+  }
+  setValues(t) {
+    Object.entries(t).forEach(([e, r]) => this.setValue(e, r));
+  }
+  async submit() {
+    await this.hooks.execute(c.BeforeSubmit, this), await this.validate(), await this.hooks.execute(c.AfterSubmit, this);
+  }
+  async validate() {
+    await this.hooks.execute(c.BeforeValidate, this);
+    const t = await Promise.all(
+      o(this.fields).map((e) => p(e, "ref") ? e.validate() : (e.resetValidation(), !0))
+    );
+    return this.isValid.value = t.every(Boolean), await this.hooks.execute(c.AfterValidate, this), o(this.isValid);
+  }
+  ensureGetField(t) {
+    const e = this.getField(t);
+    if (!e)
+      throw new Error(`Field ${t} not found in form ${this.name}`);
+    return e;
+  }
+  createFieldInstance(t, e) {
+    var a;
+    const r = {
+      ...e.config.fieldDefaults,
+      ...t,
+      attributes: {
+        ...(a = e.config.fieldDefaults) == null ? void 0 : a.attributes,
+        ...t.attributes
+      }
+    };
+    if (E(r.component), E(r.wrapper), !p(r, "ref")) {
+      const u = new oe(e, r);
+      return this.registerElement(r.name, u);
+    }
+    const i = new Ie(e, r);
+    return H(i.ref, async (u) => {
+      await this.hooks.execute(c.ElementChange, this, i, u), o(i.isDisabled) || (this.values[r.name] = u);
+    }), o(i.isDisabled) || (this.values[r.name] = v(i.ref)), this.registerElement(r.name, i);
+  }
+  registerElement(t, e) {
+    return Ee(t) && (this.model[t] = e, this.getFieldMemoized.delete(t)), e;
+  }
+}
+let D, V, R;
+const Le = "register", ne = () => (D ?? (D = f({})), V ?? (V = f(Oe())), R ?? (R = new X({
+  hookNames: [Le]
+})), {
+  forms: D,
+  defaults: V,
+  on(s, t) {
+    R.register(s, t);
+  },
+  getForm(s) {
+    return o(D)[s];
+  },
+  // @ts-expect-error todo
+  register(s, t) {
+    R.execute("beforeRegister");
+    const e = new We(s, U(o(V), t));
+    return o(D)[s] = e, R.execute("afterRegister", e), e;
+  },
+  setDefaults(s) {
+    V.value = U(o(V), s);
+  }
+}), U = (s, t) => {
+  var e, r, i, a, u, h;
+  return {
+    ...s,
+    ...t,
+    fields: [...s.fields ?? [], ...t.fields ?? []],
+    form: {
+      ...s.form,
+      ...t.form,
+      wrapper: E(((e = t.form) == null ? void 0 : e.wrapper) ?? ((r = s.form) == null ? void 0 : r.wrapper)),
+      attributes: {
+        ...s.form.attributes,
+        ...(i = t.form) == null ? void 0 : i.attributes
+      }
+    },
+    fieldDefaults: {
+      ...s.fieldDefaults,
+      ...t.fieldDefaults,
+      wrapper: E(((a = t.fieldDefaults) == null ? void 0 : a.wrapper) ?? ((u = s.fieldDefaults) == null ? void 0 : u.wrapper)),
+      attributes: {
+        ...s.fieldDefaults.attributes,
+        ...(h = t.fieldDefaults) == null ? void 0 : h.attributes
+      }
+    }
+  };
+}, ze = (s) => ({}), je = {
+  install(s, t) {
+    const e = ne();
+    s._context.config.globalProperties.$formBuilder = e, t && e.setDefaults(t);
+  }
+}, Ze = (s) => ({
+  install: (t) => je.install(t, s)
+});
+export {
+  c as FormHook,
+  xe as MagicForm,
+  je as MyParcelFormBuilderPlugin,
+  Ye as createField,
+  Qe as createForm,
+  Ze as createMyParcelFormBuilderPlugin,
+  Xe as defineField,
+  Ne as defineForm,
+  Je as useElement,
+  M as useForm,
+  ne as useFormBuilder
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@myparcel-dev/vue-form-builder",
+  "version": "1.0.0-beta.44",
+  "keywords": [
+    "vue",
+    "form-builder",
+    "form",
+    "vue3"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist"
+  ],
+  "scripts": {
+    "build": "run ws:vite:build \"$(pwd)\"",
+    "build:dev": "run ws:vite:build:dev \"$(pwd)\"",
+    "clean": "run ws:clean \"$(pwd)\"",
+    "test": "run ws:test \"$(pwd)\"",
+    "test:coverage": "run ws:test:coverage \"$(pwd)\"",
+    "test:run": "run ws:test:run \"$(pwd)\"",
+    "test:update": "run ws:test:update \"$(pwd)\"",
+    "typecheck": "run ws:vite:typecheck \"$(pwd)\""
+  },
+  "dependencies": {
+    "@myparcel-dev/ts-utils": ">= 1.6.0",
+    "@myparcel-vfb/core": "^1.0.0-beta.40",
+    "@myparcel-vfb/hook-manager": "^1.0.0-beta.12",
+    "@myparcel-vfb/plugin": "^1.0.0-beta.40",
+    "@myparcel-vfb/utils": "^1.0.0-beta.7",
+    "@vueuse/core": ">= 10.1.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^4.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "typescript": "^5.0.0",
+    "vite": "^5.0.0",
+    "vite-plugin-custom-tsconfig": "^1.0.4",
+    "vite-plugin-dts": "^2.1.0",
+    "vitest": "^1.0.0",
+    "vue": "^3.2.47",
+    "vue-tsc": "^1.6.5"
+  },
+  "peerDependencies": {
+    "vue": "^3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}