@expcat/tigercat-vue 2.1.2 → 2.1.3

package/dist/{chunk-Q7Y22OFX.mjs → chunk-Y63TRXZO.mjs}

@@ -3,18 +3,33 @@ import {
   getFocusTrapNavigation,
   getFocusableElements,
   isEventOutside,
+  isFocusInForeignOverlay,
   lockBodyScroll,
+  setBackgroundInert,
   computeFloatingPosition,
   autoUpdateFloating,
   resolveAnchoredOverlayTarget,
   getAnchoredOverlayTabTarget,
   getAnchoredOverlayLayoutClasses,
-  FLOATING_OVERLAY_Z_INDEX,
+  getOverlayDirLang,
+  isBrowser,
+  OVERLAY_Z_INDEX,
   getTransformOrigin,
   restoreFocus,
+  captureActiveElement,
+  focusFirst,
   registerEscapeDismiss
 } from "@expcat/tigercat-core";
-import { h, ref, computed, Teleport, watch, onBeforeUnmount } from "vue";
+import {
+  h,
+  ref,
+  computed,
+  Teleport,
+  watch,
+  onMounted,
+  onBeforeUnmount,
+  toValue
+} from "vue";
 var OVERLAY_LAYER_SELECTOR = "[data-tiger-overlay-layer]";
 function resolveOverlayLayer(element) {
   return element?.closest(OVERLAY_LAYER_SELECTOR) ?? null;
@@ -26,6 +41,7 @@ function useVueClickOutside({
   onOutsideClick,
   defer = false
 }) {
+  if (!isBrowser()) return () => void 0;
   let timer;
   const handler = (event) => {
     if (!enabled.value) return;
@@ -52,6 +68,7 @@ function useVueEscapeKey({
   onEscape,
   layerRef
 }) {
+  if (!isBrowser()) return () => void 0;
   let removeEntry;
   const stop = watch(
     enabled,
@@ -70,60 +87,133 @@ function useVueBodyScrollLock(enabled) {
   watch(
     enabled,
     (isEnabled, _prevEnabled, onCleanup) => {
-      if (!isEnabled) return;
+      if (!isEnabled || !isBrowser()) return;
       const unlock = lockBodyScroll();
       onCleanup(() => unlock());
     },
     { immediate: true }
   );
 }
-function renderVueBodyTeleport(children, disabled = false) {
-  const normalizedChildren = children == null ? [] : Array.isArray(children) ? children : [children];
-  return h(Teleport, { to: "body", disabled }, normalizedChildren);
+function useVueBackgroundInert(enabled, containerRef) {
+  watch(
+    [enabled, containerRef],
+    ([isEnabled, container], _prev, onCleanup) => {
+      if (!isEnabled || !container || !isBrowser()) return;
+      const release = setBackgroundInert(container);
+      onCleanup(() => release());
+    },
+    { immediate: true, flush: "post" }
+  );
 }
-function renderVueOverlayTeleport(children, target, disabled = false) {
-  if (children == null || typeof children === "boolean") return children;
-  const layeredChildren = h("div", { class: "contents", "data-tiger-overlay-layer": "" }, [
+function wrapVueOverlayLayer(children, target) {
+  const dirLang = getOverlayDirLang(target);
+  return h("div", { class: "contents", "data-tiger-overlay-layer": "", ...dirLang }, [
     children,
     h("div", { class: "contents", "data-tiger-overlay-host": "" })
   ]);
-  if (disabled || !target) return layeredChildren;
+}
+function renderVueBodyTeleport(children, disabled = false) {
+  if (children == null || typeof children === "boolean") return children;
+  const target = isBrowser() ? resolveAnchoredOverlayTarget(null) : null;
+  const layeredChildren = wrapVueOverlayLayer(children, target);
+  if (disabled || !isBrowser()) {
+    return layeredChildren;
+  }
+  return h(Teleport, { to: target ?? "body", disabled: !target }, [layeredChildren]);
+}
+function renderVueOverlayTeleport(children, target, disabled = false) {
+  if (children == null || typeof children === "boolean") return children;
+  const layeredChildren = wrapVueOverlayLayer(children, target);
+  if (disabled || !target || !isBrowser()) return layeredChildren;
   return h(Teleport, { to: target }, [layeredChildren]);
 }
-function useVueFocusTrap({ enabled, containerRef }) {
+function useVueOverlayPortalTarget() {
+  const anchorRef = ref(null);
+  const target = ref(isBrowser() ? resolveAnchoredOverlayTarget(null) : null);
+  const resolveTarget = () => {
+    target.value = isBrowser() ? resolveAnchoredOverlayTarget(anchorRef.value) : null;
+  };
+  onMounted(resolveTarget);
+  watch(anchorRef, resolveTarget, { flush: "post" });
+  return { anchorRef, target };
+}
+function useVueFocusTrap({
+  enabled,
+  containerRef,
+  inert = false,
+  autoFocus = false
+}) {
+  let releaseInert;
+  let detachTrap;
+  let restoreTarget = null;
+  const detach = () => {
+    detachTrap?.();
+    detachTrap = void 0;
+    releaseInert?.();
+    releaseInert = void 0;
+  };
+  const restore = () => {
+    if (!autoFocus) return;
+    restoreFocus(restoreTarget);
+    restoreTarget = null;
+  };
+  const teardown = () => {
+    detach();
+    restore();
+  };
   watch(
-    [enabled, containerRef],
-    ([isEnabled, container], _previous, onCleanup) => {
-      if (!isEnabled || !container) return;
+    enabled,
+    (isEnabled) => {
+      if (autoFocus && isEnabled && !restoreTarget) {
+        restoreTarget = captureActiveElement();
+      }
+      if (!isEnabled || !isBrowser()) teardown();
+    },
+    { flush: "sync", immediate: true }
+  );
+  watch(
+    [enabled, containerRef, () => toValue(inert)],
+    ([isEnabled, container, inertEnabled]) => {
+      detach();
+      if (!isEnabled || !container || !isBrowser()) return;
       const ownerDocument = container.ownerDocument;
+      releaseInert = inertEnabled ? setBackgroundInert(container) : void 0;
+      if (autoFocus) {
+        const focusables = getFocusableElements(container);
+        focusFirst([...focusables, container]);
+      }
       const handler = (event) => {
-        if (!(event.target instanceof Node) || !container.contains(event.target)) return;
         const focusables = getFocusableElements(container);
         const activeElement = ownerDocument.activeElement;
+        const inside = activeElement instanceof Node && container.contains(activeElement);
+        if (!inside) {
+          if (event.key !== "Tab") return;
+          if (isFocusInForeignOverlay(container, activeElement)) return;
+          event.preventDefault();
+          const next = event.shiftKey ? focusables[focusables.length - 1] : focusables[0];
+          next?.focus();
+          return;
+        }
         const navigation = getFocusTrapNavigation(event, focusables, activeElement);
-        if (!navigation.shouldHandle || !navigation.next) return;
+        if (!navigation.shouldHandle) return;
         event.preventDefault();
-        navigation.next.focus();
+        navigation.next?.focus();
       };
       ownerDocument.addEventListener("keydown", handler, true);
-      onCleanup(() => ownerDocument.removeEventListener("keydown", handler, true));
+      detachTrap = () => ownerDocument.removeEventListener("keydown", handler, true);
     },
     { immediate: true, flush: "post" }
   );
+  onBeforeUnmount(teardown);
 }
 function useVueFloating(options) {
-  const {
-    referenceRef,
-    floatingRef,
-    enabled,
-    placement: initialPlacement = "bottom",
-    offset: offsetDistance = 8,
-    arrowRef,
-    onPlacementChange
-  } = options;
+  const { referenceRef, floatingRef, enabled, onPlacementChange } = options;
+  const requestedPlacement = () => toValue(options.placement) ?? "bottom";
+  const requestedOffset = () => toValue(options.offset) ?? 8;
+  const requestedArrow = () => toValue(options.arrowRef) ?? null;
   const x = ref(0);
   const y = ref(0);
-  const placement = ref(initialPlacement);
+  const placement = ref(requestedPlacement());
   const arrowX = ref(void 0);
   const arrowY = ref(void 0);
   const isPositioned = ref(false);
@@ -136,11 +226,11 @@ function useVueFloating(options) {
     const floating = floatingRef.value;
     if (!enabled.value || !reference || !floating) return;
     const floatingOptions = {
-      placement: initialPlacement,
-      offset: offsetDistance,
+      placement: requestedPlacement(),
+      offset: requestedOffset(),
       flip: true,
       shift: true,
-      arrowElement: arrowRef?.value
+      arrowElement: requestedArrow()
     };
     const result = await computeFloatingPosition(
       reference,
@@ -164,14 +254,21 @@ function useVueFloating(options) {
     isPositioned.value = true;
   };
   watch(
-    [enabled, referenceRef, floatingRef],
+    () => [
+      enabled.value,
+      referenceRef.value,
+      floatingRef.value,
+      requestedPlacement(),
+      requestedOffset(),
+      requestedArrow()
+    ],
     ([isEnabled, reference, floating]) => {
       updateRequest += 1;
       if (cleanup) {
         cleanup();
         cleanup = null;
       }
-      if (!isEnabled || !reference || !floating) {
+      if (!isEnabled || !reference || !floating || !isBrowser()) {
         isPositioned.value = false;
         return;
       }
@@ -199,32 +296,19 @@ function useVueFloating(options) {
   };
 }
 function useVueAnchoredOverlay(options) {
-  const target = ref(null);
   const floatingLayerRef = computed(
     () => resolveOverlayLayer(options.floatingRef.value) ?? options.floatingRef.value
   );
   const portalEnabled = () => typeof options.portal === "object" ? options.portal.value : options.portal ?? true;
   const optionEnabled = (value) => typeof value === "object" ? value.value : Boolean(value);
-  const targetSources = [
-    options.enabled,
-    options.referenceRef,
-    ...typeof options.portal === "object" ? [options.portal] : []
-  ];
-  watch(
-    targetSources,
-    () => {
-      if (!portalEnabled()) {
-        target.value = null;
-        return;
-      }
-      target.value = resolveAnchoredOverlayTarget(options.referenceRef.value);
-    },
-    { immediate: true, flush: "post" }
-  );
+  const target = computed(() => {
+    if (!portalEnabled() || !isBrowser()) return null;
+    return toValue(options.getContainer) ?? resolveAnchoredOverlayTarget(options.referenceRef.value);
+  });
   watch(
     [options.enabled, options.floatingRef],
     ([enabled, floating2], _previous, onCleanup) => {
-      if (!enabled || !floating2) return;
+      if (!enabled || !floating2 || !isBrowser()) return;
       const handleTab = (event) => {
         if (event.key !== "Tab") return;
         const target2 = getAnchoredOverlayTabTarget(
@@ -245,8 +329,9 @@ function useVueAnchoredOverlay(options) {
     referenceRef: options.referenceRef,
     floatingRef: options.floatingRef,
     enabled: options.enabled,
-    placement: options.placement ?? "bottom-start",
-    offset: options.offset ?? 4
+    placement: () => toValue(options.placement) ?? "bottom-start",
+    offset: () => toValue(options.offset) ?? 4,
+    arrowRef: options.arrowRef
   });
   const dismiss = (reason) => {
     options.onDismiss?.(reason);
@@ -300,13 +385,13 @@ function useVueAnchoredOverlay(options) {
     "--tiger-overlay-x": `${floating.x.value}px`,
     "--tiger-overlay-y": `${floating.y.value}px`,
     "--tiger-overlay-reference-width": `${floating.referenceWidth.value}px`,
-    zIndex: FLOATING_OVERLAY_Z_INDEX,
+    zIndex: OVERLAY_Z_INDEX.overlay,
     transformOrigin: getTransformOrigin(floating.placement.value)
   }));
   const floatingClasses = computed(
     () => getAnchoredOverlayLayoutClasses(
-      options.layout ?? "anchored",
-      options.matchReferenceWidth ?? false
+      toValue(options.layout) ?? "anchored",
+      toValue(options.matchReferenceWidth) ?? false
     )
   );
   return {
@@ -316,15 +401,20 @@ function useVueAnchoredOverlay(options) {
     positioned: floating.isPositioned,
     placement: floating.placement,
     x: floating.x,
-    y: floating.y
+    y: floating.y,
+    arrowX: floating.arrowX,
+    arrowY: floating.arrowY
   };
 }
 
 export {
+  useVueClickOutside,
   useVueEscapeKey,
   useVueBodyScrollLock,
+  useVueBackgroundInert,
   renderVueBodyTeleport,
   renderVueOverlayTeleport,
+  useVueOverlayPortalTarget,
   useVueFocusTrap,
   useVueAnchoredOverlay
 };

package/dist/chunk-YPONYV6R.mjs

@@ -0,0 +1,366 @@
+import {
+  FormContextKey
+} from "./chunk-ONSDH4KJ.mjs";
+import {
+  FORM_ITEM_CONTROL_INJECTION_KEY
+} from "./chunk-P2LZ2MR5.mjs";
+import {
+  renderVueOverlayTeleport,
+  useVueAnchoredOverlay
+} from "./chunk-Y63TRXZO.mjs";
+
+// src/components/FormItem.ts
+import {
+  defineComponent,
+  inject,
+  provide,
+  computed,
+  ref,
+  watch,
+  h,
+  onUnmounted,
+  cloneVNode,
+  isVNode,
+  useId
+} from "vue";
+import {
+  classNames,
+  devWarn,
+  extractFormChangeValue,
+  getFormItemAsteriskClasses,
+  getFormItemClasses,
+  getFormItemContentClasses,
+  getFormItemErrorBlockClasses,
+  getFormItemErrorClasses,
+  getFormItemErrorPopupClasses,
+  getFormItemFieldClasses,
+  getFormItemLabelClasses,
+  hasRequiredRule,
+  isFormItemGroupControl,
+  mergeAriaDescribedBy
+} from "@expcat/tigercat-core";
+var FormItem = defineComponent({
+  name: "TigerFormItem",
+  props: {
+    name: {
+      type: String
+    },
+    label: {
+      type: String
+    },
+    labelWidth: {
+      type: [String, Number]
+    },
+    required: {
+      type: Boolean,
+      default: void 0
+    },
+    rules: {
+      type: [Object, Array]
+    },
+    error: {
+      type: String
+    },
+    showMessage: {
+      type: Boolean,
+      default: true
+    },
+    size: {
+      type: String
+    },
+    errorDisplayMode: {
+      type: String,
+      default: "inline"
+    },
+    condition: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const formContextRef = inject(FormContextKey, null);
+    const formContext = computed(() => formContextRef?.value ?? null);
+    const shakeTrigger = ref(0);
+    const prevFormError = ref("");
+    const popupActive = ref(false);
+    const contentRef = ref(null);
+    const errorRef = ref(null);
+    const instanceId = useId();
+    const baseId = `tiger-form-item-${instanceId}`;
+    const labelId = `${baseId}-label`;
+    const fieldId = `${baseId}-field`;
+    const errorId = `${baseId}-error`;
+    const actualSize = computed(() => props.size || formContext.value?.size || "md");
+    const actualLabelWidth = computed(() => {
+      const width = props.labelWidth || formContext.value?.labelWidth;
+      if (typeof width === "number") {
+        return `${width}px`;
+      }
+      return width;
+    });
+    const labelPosition = computed(() => formContext.value?.labelPosition || "left");
+    const labelAlign = computed(() => formContext.value?.labelAlign);
+    const conditionState = computed(() => {
+      const ctx = formContext.value;
+      if (!props.name || !ctx) {
+        return { shown: true, disabled: false, required: false };
+      }
+      return ctx.getFieldConditionState(props.name, props.condition);
+    });
+    const fieldIsRequired = computed(() => {
+      if (props.required !== void 0) return props.required;
+      if (hasRequiredRule(props.rules)) return true;
+      if (props.name && hasRequiredRule(formContext.value?.rules?.[props.name])) return true;
+      return conditionState.value.required;
+    });
+    const showAsterisk = computed(
+      () => fieldIsRequired.value && (formContext.value?.showRequiredAsterisk ?? true)
+    );
+    const formError = computed(
+      () => props.name ? formContext.value?.errorsByField[props.name] : void 0
+    );
+    const errorMessage = computed(
+      () => props.error !== void 0 ? props.error : formError.value ?? ""
+    );
+    const hasError = computed(() => !!errorMessage.value);
+    watch(
+      errorMessage,
+      (nextError) => {
+        if (nextError && nextError !== prevFormError.value) {
+          shakeTrigger.value++;
+        }
+        prevFormError.value = nextError;
+      },
+      { immediate: true }
+    );
+    const unregisterFieldRules = () => {
+      const ctx = formContext.value;
+      if (props.name && ctx) {
+        ctx.registerFieldRules(props.name, void 0);
+        ctx.registerFieldCondition(props.name, void 0);
+      }
+    };
+    watch(
+      () => [props.name, props.rules, props.condition],
+      ([name, rules, condition]) => {
+        const ctx = formContext.value;
+        if (!name || !ctx) return;
+        if (rules) {
+          ctx.registerFieldRules(name, rules);
+        } else {
+          ctx.registerFieldRules(name, void 0);
+        }
+        ctx.registerFieldCondition(name, condition);
+      },
+      { immediate: true }
+    );
+    onUnmounted(unregisterFieldRules);
+    const handleBlur = () => {
+      const ctx = formContext.value;
+      if (props.name && ctx) {
+        ctx.validateField(props.name, props.rules, "blur");
+      }
+    };
+    const handleValueChange = (next) => {
+      const ctx = formContext.value;
+      if (!props.name || !ctx) return;
+      ctx.updateValue(props.name, next);
+      ctx.validateField(props.name, props.rules, "change");
+    };
+    const handleNativeChange = (argument) => {
+      const extracted = extractFormChangeValue(argument);
+      if (extracted.found) {
+        handleValueChange(extracted.value);
+      } else {
+        const ctx = formContext.value;
+        if (props.name && ctx) {
+          ctx.validateField(props.name, props.rules, "change");
+        }
+      }
+    };
+    const effectiveShowMessage = computed(
+      () => props.showMessage && (formContext.value?.inlineMessage ?? true)
+    );
+    const popupErrorVisible = computed(
+      () => effectiveShowMessage.value && hasError.value && props.errorDisplayMode === "popup" && popupActive.value
+    );
+    const overlay = useVueAnchoredOverlay({
+      enabled: popupErrorVisible,
+      referenceRef: contentRef,
+      floatingRef: errorRef,
+      placement: "bottom-start",
+      offset: 4
+    });
+    const describedById = computed(
+      () => effectiveShowMessage.value && hasError.value ? errorId : void 0
+    );
+    const fieldValue = computed(() => {
+      if (!props.name) return void 0;
+      return formContext.value?.getFieldValue(props.name) ?? "";
+    });
+    const controlDisabled = computed(
+      () => Boolean(
+        formContext.value?.disabled || formContext.value?.loading || conditionState.value.disabled
+      )
+    );
+    const effectiveFieldId = computed(() => fieldId);
+    provide(FORM_ITEM_CONTROL_INJECTION_KEY, {
+      id: effectiveFieldId,
+      labelId: computed(() => props.label ? labelId : void 0),
+      name: computed(() => props.name),
+      status: computed(() => hasError.value ? "error" : void 0),
+      shakeTrigger: computed(() => hasError.value ? shakeTrigger.value : void 0),
+      disabled: controlDisabled,
+      describedBy: describedById,
+      required: fieldIsRequired,
+      value: fieldValue,
+      onChange: handleValueChange,
+      onBlur: handleBlur
+    });
+    const formItemClasses = computed(
+      () => getFormItemClasses({
+        size: actualSize.value,
+        labelPosition: labelPosition.value,
+        hasError: hasError.value,
+        disabled: controlDisabled.value
+      })
+    );
+    const labelClasses = computed(
+      () => getFormItemLabelClasses({
+        size: actualSize.value,
+        labelAlign: labelAlign.value,
+        labelPosition: labelPosition.value,
+        isRequired: showAsterisk.value
+      })
+    );
+    const labelStyles = computed(() => {
+      if (labelPosition.value === "top") return {};
+      return actualLabelWidth.value ? { width: actualLabelWidth.value } : {};
+    });
+    const fieldClasses = getFormItemFieldClasses();
+    const asteriskClasses = getFormItemAsteriskClasses();
+    return () => {
+      if (!conditionState.value.shown) {
+        return null;
+      }
+      const defaultSlot = slots.default?.() ?? [];
+      const only = defaultSlot.length === 1 ? defaultSlot[0] : void 0;
+      const isNativeElement = only != null && isVNode(only) && typeof only.type === "string";
+      const useGroup = defaultSlot.length !== 1;
+      const isGroupControl = only != null && isVNode(only) && isFormItemGroupControl(only.type);
+      if (useGroup && props.name) {
+        devWarn(
+          "FormItem.multipleControls",
+          "FormItem supports a single field control. Extra children do not receive value or validation bindings."
+        );
+      }
+      const nativeId = isNativeElement && only ? (only.props ?? {}).id : void 0;
+      const controlId = nativeId ?? fieldId;
+      const fieldChildren = (() => {
+        if (!isNativeElement || !only) {
+          return defaultSlot;
+        }
+        const vnode = only;
+        const existingProps = vnode.props ?? {};
+        const nativeType = typeof existingProps.type === "string" ? existingProps.type.toLowerCase() : "";
+        const next = {
+          id: controlId,
+          name: existingProps.name ?? props.name,
+          "aria-invalid": hasError.value ? "true" : existingProps["aria-invalid"],
+          "aria-required": fieldIsRequired.value ? "true" : existingProps["aria-required"],
+          disabled: controlDisabled.value ? true : existingProps.disabled,
+          "aria-describedby": mergeAriaDescribedBy(
+            existingProps["aria-describedby"],
+            describedById.value
+          ),
+          onFocusout: handleBlur,
+          onInput: handleNativeChange,
+          onChange: handleNativeChange
+        };
+        if (nativeType === "checkbox") {
+          next.checked = Boolean(fieldValue.value);
+        } else if (nativeType === "radio") {
+          next.checked = existingProps.value === fieldValue.value;
+        } else if (fieldValue.value !== void 0) {
+          next.value = fieldValue.value;
+        }
+        return [cloneVNode(vnode, next, true)];
+      })();
+      const labelElement = props.label ? h(
+        "label",
+        {
+          class: labelClasses.value,
+          style: labelStyles.value,
+          id: labelId,
+          for: isGroupControl ? void 0 : controlId
+        },
+        [showAsterisk.value && h("span", { class: asteriskClasses }, "*"), props.label]
+      ) : null;
+      const errorElement = (() => {
+        if (!effectiveShowMessage.value) return null;
+        if (props.errorDisplayMode === "block" && !hasError.value) return null;
+        if (props.errorDisplayMode === "popup" && !hasError.value) return null;
+        const errorClass = props.errorDisplayMode === "block" ? getFormItemErrorBlockClasses(actualSize.value) : props.errorDisplayMode === "popup" ? classNames(getFormItemErrorPopupClasses(), overlay.floatingClasses.value) : getFormItemErrorClasses(actualSize.value, { visible: hasError.value });
+        return renderVueOverlayTeleport(
+          h(
+            "div",
+            {
+              ref: errorRef,
+              id: hasError.value ? errorId : void 0,
+              role: hasError.value ? "alert" : void 0,
+              class: errorClass,
+              style: props.errorDisplayMode === "popup" ? overlay.floatingStyles.value : void 0,
+              "data-positioned": props.errorDisplayMode === "popup" ? overlay.positioned.value : void 0,
+              "aria-hidden": hasError.value ? void 0 : "true"
+            },
+            hasError.value ? errorMessage.value : ""
+          ),
+          overlay.target.value,
+          props.errorDisplayMode !== "popup"
+        );
+      })();
+      const fieldWrapper = {
+        class: fieldClasses
+      };
+      if (useGroup) {
+        fieldWrapper.role = "group";
+        fieldWrapper["aria-labelledby"] = props.label ? labelId : void 0;
+        fieldWrapper["aria-describedby"] = describedById.value;
+        fieldWrapper["aria-invalid"] = hasError.value ? "true" : void 0;
+      }
+      const contentElement = h(
+        "div",
+        {
+          ref: contentRef,
+          class: classNames(
+            getFormItemContentClasses(labelPosition.value),
+            props.errorDisplayMode === "popup" && "relative"
+          ),
+          onMouseenter: () => {
+            popupActive.value = true;
+          },
+          onMouseleave: () => {
+            popupActive.value = false;
+          },
+          onFocusin: () => {
+            popupActive.value = true;
+          },
+          onFocusout: (event) => {
+            const next = event.relatedTarget;
+            if (!contentRef.value?.contains(next)) {
+              popupActive.value = false;
+            }
+          }
+        },
+        [h("div", fieldWrapper, fieldChildren), errorElement]
+      );
+      return h("div", { class: formItemClasses.value }, [labelElement, contentElement]);
+    };
+  }
+});
+var FormItem_default = FormItem;
+
+export {
+  FormItem,
+  FormItem_default
+};