@volverjs/ui-vue 0.0.10-beta.12 → 0.0.10-beta.13

package/dist/components/VvInputFile/VvInputFile.es.js

@@ -0,0 +1,1529 @@
+import { inject, computed, unref, defineComponent, ref, toRefs, openBlock, createBlock, mergeProps, createCommentVNode, watch, resolveDynamicComponent, withCtx, renderSlot, createTextVNode, toDisplayString, toRef, useAttrs, useSlots, createElementBlock, Fragment, isRef, h, onBeforeUnmount, normalizeClass, withModifiers, createVNode, createElementVNode, renderList, createSlots, normalizeProps, guardReactiveProps } from "vue";
+import { useVModel } from "@vueuse/core";
+import { iconExists, Icon, addIcon } from "@iconify/vue";
+import { uid } from "uid";
+const VvIconProps = {
+  /**
+   * Color
+   */
+  color: String,
+  /**
+   * Width
+   */
+  width: {
+    type: [String, Number]
+  },
+  /**
+   * Height
+   */
+  height: {
+    type: [String, Number]
+  },
+  /**
+   * Icon name
+   * Can be the full composition of iconify name "@{provider}:{prefix}:{name}" or "{prefix}:{name}" or "{name}"
+   * https://docs.iconify.design/api/providers.html#provider-in-icon-name
+   */
+  name: {
+    type: String,
+    required: true
+  },
+  /**
+   * By default 'vv'
+   * If custom collection is not added with "addCollection" DS class method, this prop could not be used
+   * Icon provider: https://docs.iconify.design/api/providers.html#provider-in-icon-name
+   */
+  provider: {
+    type: String
+  },
+  /**
+   * The name of icon set.
+   * Icon default options prefix: simple | normal | detailed
+   */
+  prefix: {
+    type: String,
+    default: "normal"
+  },
+  /**
+   * Url remote SVG icon
+   */
+  src: String,
+  /**
+   * Horizontal flip
+   */
+  horizontalFlip: Boolean,
+  /**
+   * Vertical flip
+   */
+  verticalFlip: Boolean,
+  /**
+   * String alternative to "horizontalFlip" and "verticalFlip".
+   * Example: https://docs.iconify.design/icon-components/vue/transform.html
+   */
+  flip: String,
+  /**
+   * Icon render mode
+   * 'style' = 'bg' or 'mask', depending on icon content
+   * 'bg' = span with style using `background`
+   * 'mask' = span with style using `mask`
+   * 'svg' = svg
+   * Iconify doc: https://docs.iconify.design/iconify-icon/modes.html
+   */
+  mode: String,
+  /**
+   * Toggles inline or block mode
+   * Example https://docs.iconify.design/icon-components/vue/inline.html
+   */
+  inline: Boolean,
+  /**
+   * rotates icon
+   * Example https://docs.iconify.design/icon-components/vue/transform.html
+   */
+  rotate: [Number, String],
+  /**
+   * A callback that is called when icon data has been loaded
+   */
+  onLoad: Function,
+  /**
+   * SVG icon string
+   */
+  svg: String,
+  /**
+   * Icon modifiers: vv-icon css helper classes, value/s are concatened with prefix 'vv-icon--'
+   * @values string | string[]
+   */
+  modifiers: {
+    type: [String, Array]
+  }
+};
+var Strategy = /* @__PURE__ */ ((Strategy2) => {
+  Strategy2["absolute"] = "absolute";
+  Strategy2["fixed"] = "fixed";
+  return Strategy2;
+})(Strategy || {});
+var Side = /* @__PURE__ */ ((Side2) => {
+  Side2["left"] = "left";
+  Side2["right"] = "right";
+  Side2["top"] = "top";
+  Side2["bottom"] = "bottom";
+  return Side2;
+})(Side || {});
+var Placement = /* @__PURE__ */ ((Placement2) => {
+  Placement2["topStart"] = "top-start";
+  Placement2["topEnd"] = "top-end";
+  Placement2["bottomStart"] = "bottom-start";
+  Placement2["bottomEnd"] = "bottom-end";
+  Placement2["leftStart"] = "left-start";
+  Placement2["leftEnd"] = "left-end";
+  Placement2["rightStart"] = "right-start";
+  Placement2["rightEnd"] = "right-end";
+  return Placement2;
+})(Placement || {});
+var Position = /* @__PURE__ */ ((Position2) => {
+  Position2["before"] = "before";
+  Position2["after"] = "after";
+  return Position2;
+})(Position || {});
+var ButtonType = /* @__PURE__ */ ((ButtonType2) => {
+  ButtonType2["button"] = "button";
+  ButtonType2["submit"] = "submit";
+  ButtonType2["reset"] = "reset";
+  return ButtonType2;
+})(ButtonType || {});
+var ActionTag = /* @__PURE__ */ ((ActionTag2) => {
+  ActionTag2["nuxtLink"] = "nuxt-link";
+  ActionTag2["routerLink"] = "router-link";
+  ActionTag2["a"] = "a";
+  ActionTag2["button"] = "button";
+  return ActionTag2;
+})(ActionTag || {});
+var AnchorTarget = /* @__PURE__ */ ((AnchorTarget2) => {
+  AnchorTarget2["_blank"] = "_blank";
+  AnchorTarget2["_self"] = "_self";
+  AnchorTarget2["_parent"] = "_parent";
+  AnchorTarget2["_top"] = "_top";
+  return AnchorTarget2;
+})(AnchorTarget || {});
+const INJECTION_KEY_VOLVER = Symbol.for("volver");
+const INJECTION_KEY_BUTTON_GROUP = Symbol.for("buttonGroup");
+const INJECTION_KEY_DROPDOWN_TRIGGER = Symbol.for(
+  "dropdownTrigger"
+);
+const INJECTION_KEY_DROPDOWN_ACTION = Symbol.for(
+  "dropdownAction"
+);
+function useVolver() {
+  return inject(INJECTION_KEY_VOLVER);
+}
+function useModifiers(prefix, modifiers, others) {
+  return computed(() => {
+    const toReturn = {
+      [prefix]: true
+    };
+    const modifiersArray = typeof (modifiers == null ? void 0 : modifiers.value) === "string" ? modifiers.value.split(" ") : modifiers == null ? void 0 : modifiers.value;
+    if (modifiersArray) {
+      if (Array.isArray(modifiersArray)) {
+        modifiersArray.forEach((modifier) => {
+          if (modifier) {
+            toReturn[`${prefix}--${modifier}`] = true;
+          }
+        });
+      }
+    }
+    if (others) {
+      Object.keys(others.value).forEach((key) => {
+        toReturn[`${prefix}--${key}`] = unref(others.value[key]);
+      });
+    }
+    return toReturn;
+  });
+}
+const __default__$3 = {
+  name: "VvIcon"
+};
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  ...__default__$3,
+  props: VvIconProps,
+  setup(__props) {
+    const props = __props;
+    const hasRotate = computed(() => {
+      if (typeof props.rotate === "string") {
+        return parseFloat(props.rotate);
+      }
+      return props.rotate;
+    });
+    const show = ref(true);
+    const volver = useVolver();
+    const { modifiers } = toRefs(props);
+    const bemCssClasses = useModifiers("vv-icon", modifiers);
+    const provider = computed(() => {
+      return props.provider || (volver == null ? void 0 : volver.iconsProvider);
+    });
+    const icon = computed(() => {
+      const name = props.name ?? "";
+      const iconName = `@${provider.value}:${props.prefix}:${name}`;
+      if (iconExists(iconName)) {
+        return iconName;
+      }
+      const iconsCollection = volver == null ? void 0 : volver.iconsCollections.find(
+        (iconsCollection2) => {
+          const icon2 = `@${provider.value}:${iconsCollection2.prefix}:${name}`;
+          return iconExists(icon2);
+        }
+      );
+      if (iconsCollection) {
+        return `@${provider.value}:${iconsCollection.prefix}:${name}`;
+      }
+      return name;
+    });
+    function getSvgContent(svg) {
+      let dom;
+      if (typeof window === "undefined") {
+        const { JSDOM } = require("jsdom");
+        dom = new JSDOM().window;
+      }
+      const domParser = dom ? new dom.DOMParser() : new window.DOMParser();
+      const svgDomString = domParser.parseFromString(svg, "text/html");
+      const svgEl = svgDomString.querySelector("svg");
+      return svgEl;
+    }
+    function addIconFromSvg(svg) {
+      const svgContentEl = getSvgContent(svg);
+      const svgContent = (svgContentEl == null ? void 0 : svgContentEl.innerHTML.trim()) || "";
+      if (svgContentEl && svgContent) {
+        addIcon(`@${provider.value}:${props.prefix}:${props.name}`, {
+          body: svgContent,
+          // Set height and width from svg content
+          height: svgContentEl.viewBox.baseVal.height,
+          width: svgContentEl.viewBox.baseVal.width
+        });
+      }
+    }
+    if (volver) {
+      if (props.src && !iconExists(`@${provider.value}:${props.prefix}:${props.name}`)) {
+        show.value = false;
+        volver.fetchIcon(props.src).then((svg) => {
+          if (svg) {
+            addIconFromSvg(svg);
+            show.value = true;
+          }
+        }).catch((e) => {
+          throw new Error(`Error during fetch icon: ${e == null ? void 0 : e.message}`);
+        });
+      }
+    }
+    if (props.svg) {
+      addIconFromSvg(props.svg);
+    }
+    return (_ctx, _cache) => {
+      return unref(show) ? (openBlock(), createBlock(unref(Icon), mergeProps({
+        key: 0,
+        class: unref(bemCssClasses)
+      }, {
+        inline: _ctx.inline,
+        width: _ctx.width,
+        height: _ctx.height,
+        horizontalFlip: _ctx.horizontalFlip,
+        verticalFlip: _ctx.verticalFlip,
+        flip: _ctx.flip,
+        rotate: unref(hasRotate),
+        color: _ctx.color,
+        onLoad: _ctx.onLoad,
+        icon: unref(icon)
+      }), null, 16, ["class"])) : createCommentVNode("v-if", true);
+    };
+  }
+});
+const LinkProps = {
+  /**
+   * The router-link/nuxt-link property, if it is defined the button is rendered as a ruouter-link or nuxt-link.
+   * @see Documentation of [router-link](https://router.vuejs.org/api/#router-link) and [nuxt-link](https://nuxtjs.org/api/components-nuxt-link/)
+   */
+  to: {
+    type: [String, Object]
+  },
+  /**
+   * Anchor href
+   */
+  href: String,
+  /**
+   * Anchor target
+   */
+  target: {
+    type: String,
+    validator: (value) => Object.values(AnchorTarget).includes(value)
+  },
+  /**
+   * Anchor rel
+   */
+  rel: {
+    type: String,
+    default: "noopener noreferrer"
+  }
+};
+const ValidProps = {
+  /**
+   * Valid status
+   */
+  valid: Boolean,
+  /**
+   * Valid label
+   */
+  validLabel: [String, Array]
+};
+const InvalidProps = {
+  /**
+   * Invalid status
+   */
+  invalid: Boolean,
+  /**
+   * Invalid label
+   */
+  invalidLabel: [String, Array]
+};
+const LoadingProps = {
+  /**
+   * Loading status
+   */
+  loading: Boolean,
+  /**
+   * Loading label
+   */
+  loadingLabel: {
+    type: String,
+    default: "Loading..."
+  }
+};
+const DisabledProps = {
+  /**
+   * Whether the form control is disabled
+   */
+  disabled: Boolean
+};
+const ActiveProps = {
+  /**
+   * Whether the item is active
+   */
+  active: Boolean
+};
+const CurrentProps = {
+  /**
+   * Whether the item is current
+   */
+  current: Boolean
+};
+const PressedProps = {
+  /**
+   * Whether the item is pressed
+   */
+  pressed: Boolean
+};
+const LabelProps = {
+  /**
+   * The item label
+   */
+  label: [String, Number]
+};
+const ModifiersProps = {
+  /**
+   * Component BEM modifiers
+   */
+  modifiers: [String, Array]
+};
+const HintProps = {
+  hintLabel: { type: String, default: "" }
+};
+({
+  /**
+   * VvIcon name or props
+   * @see VVIcon
+   */
+  icon: { type: [String, Object] },
+  /**
+   * VvIcon position
+   */
+  iconPosition: {
+    type: String,
+    default: Position.before,
+    validation: (value) => Object.values(Position).includes(value)
+  }
+});
+const UnselectableProps = {
+  /**
+   * If true the input will be unselectable
+   */
+  unselectable: { type: Boolean, default: true }
+};
+const IdProps = {
+  /**
+   * Global attribute id
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id
+   */
+  id: [String, Number]
+};
+({
+  /**
+   * Dropdown placement
+   */
+  placement: {
+    type: String,
+    default: Side.bottom,
+    validator: (value) => Object.values(Side).includes(value) || Object.values(Placement).includes(value)
+  },
+  /**
+   * Dropdown strategy
+   */
+  strategy: {
+    type: String,
+    default: void 0,
+    validator: (value) => Object.values(Strategy).includes(value)
+  },
+  /**
+   * Dropdown show / hide transition name
+   */
+  transitionName: {
+    type: String
+  },
+  /**
+   * Offset of the dropdown from the trigger
+   * @see https://floating-ui.com/docs/offset
+   */
+  offset: {
+    type: [Number, String, Object],
+    default: 0
+  },
+  /**
+   * Move dropdown to the side if there is no space in the default position
+   * @see https://floating-ui.com/docs/shift
+   */
+  shift: {
+    type: [Boolean, Object],
+    default: false
+  },
+  /**
+   * Flip dropdown position if there is no space in the default position
+   * @see https://floating-ui.com/docs/flip
+   */
+  flip: {
+    type: [Boolean, Object],
+    default: true
+  },
+  /**
+   * Size of the dropdown
+   * @see https://floating-ui.com/docs/size
+   */
+  size: {
+    type: [Boolean, Object],
+    default: () => ({ padding: 10 })
+  },
+  /**
+   * Automatically change the position of the dropdown
+   * @see https://floating-ui.com/docs/autoPlacement
+   */
+  autoPlacement: {
+    type: [Boolean, Object],
+    default: false
+  },
+  /**
+   * Add arrow to the dropdown
+   * @see https://floating-ui.com/docs/arrow
+   */
+  arrow: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * Keep open dropdown on click outside
+   */
+  keepOpen: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * Autofocus first item on dropdown open
+   */
+  autofocusFirst: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * Set dropdown width to the same as the trigger
+   */
+  triggerWidth: {
+    type: Boolean
+  }
+});
+const ActionProps = {
+  ...DisabledProps,
+  ...LabelProps,
+  ...PressedProps,
+  ...ActiveProps,
+  ...CurrentProps,
+  ...LinkProps,
+  /**
+   * Button type
+   */
+  type: {
+    type: String,
+    default: ButtonType.button,
+    validator: (value) => Object.values(ButtonType).includes(value)
+  },
+  /**
+   * Button aria-label
+   */
+  ariaLabel: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * Default tag for the action
+   */
+  defaultTag: {
+    type: String,
+    default: ActionTag.button
+  }
+};
+const VvActionEvents = ["click", "mouseover", "mouseleave"];
+const VvActionProps = ActionProps;
+function useInjectedDropdownTrigger() {
+  return inject(INJECTION_KEY_DROPDOWN_TRIGGER, {});
+}
+function useInjectedDropdownAction() {
+  return inject(INJECTION_KEY_DROPDOWN_ACTION, {});
+}
+const __default__$2 = {
+  name: "VvAction"
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...__default__$2,
+  props: VvActionProps,
+  emits: VvActionEvents,
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const volver = useVolver();
+    const element = ref(null);
+    __expose({ $el: element });
+    const {
+      reference: dropdownTriggerReference,
+      bus: dropdownEventBus,
+      aria: dropdownAria,
+      expanded: dropdownExpanded
+    } = useInjectedDropdownTrigger();
+    watch(
+      () => element.value,
+      (newValue) => {
+        if (dropdownTriggerReference) {
+          dropdownTriggerReference.value = newValue;
+        }
+      }
+    );
+    const pressed = computed(() => {
+      return props.pressed || (dropdownExpanded == null ? void 0 : dropdownExpanded.value);
+    });
+    const { role } = useInjectedDropdownAction();
+    const hasTag = computed(() => {
+      switch (true) {
+        case props.disabled:
+          return ActionTag.button;
+        case props.to !== void 0:
+          return (volver == null ? void 0 : volver.nuxt) ? ActionTag.nuxtLink : ActionTag.routerLink;
+        case props.href !== void 0:
+          return ActionTag.a;
+        default:
+          return props.defaultTag;
+      }
+    });
+    const hasProps = computed(() => {
+      const toReturn = {
+        ...dropdownAria == null ? void 0 : dropdownAria.value,
+        ariaPressed: pressed.value ? true : void 0,
+        ariaLabel: props.ariaLabel,
+        role: role == null ? void 0 : role.value
+      };
+      switch (hasTag.value) {
+        case ActionTag.a:
+          return {
+            ...toReturn,
+            href: props.href,
+            target: props.target,
+            rel: props.rel
+          };
+        case ActionTag.routerLink:
+        case ActionTag.nuxtLink:
+          return {
+            ...toReturn,
+            to: props.to,
+            target: props.target
+          };
+        case ActionTag.button:
+          return {
+            ...toReturn,
+            type: props.type,
+            disabled: props.disabled
+          };
+        default:
+          return toReturn;
+      }
+    });
+    const onClick = (e) => {
+      if (props.disabled) {
+        e.preventDefault();
+        return;
+      }
+      dropdownEventBus == null ? void 0 : dropdownEventBus.emit("click", e);
+      emit("click", e);
+    };
+    const onMouseover = (e) => {
+      dropdownEventBus == null ? void 0 : dropdownEventBus.emit("mouseover", e);
+      emit("mouseover", e);
+    };
+    const onMouseleave = (e) => {
+      dropdownEventBus == null ? void 0 : dropdownEventBus.emit("mouseleave", e);
+      emit("mouseleave", e);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(unref(hasTag)), mergeProps(unref(hasProps), {
+        ref_key: "element",
+        ref: element,
+        class: {
+          active: _ctx.active,
+          pressed: unref(pressed),
+          disabled: _ctx.disabled,
+          current: _ctx.current
+        },
+        onClickPassive: onClick,
+        onMouseoverPassive: onMouseover,
+        onMouseleavePassive: onMouseleave
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(
+              toDisplayString(_ctx.label),
+              1
+              /* TEXT */
+            )
+          ])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["class"]);
+    };
+  }
+});
+function equals(obj1, obj2, field) {
+  if (field) {
+    return resolveFieldData(obj1, field) === resolveFieldData(obj2, field);
+  }
+  return deepEquals(obj1, obj2);
+}
+function deepEquals(a, b) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a == "object" && typeof b == "object") {
+    const arrA = Array.isArray(a);
+    const arrB = Array.isArray(b);
+    let i, length, key;
+    if (arrA && arrB) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (!deepEquals(a[i], b[i]))
+          return false;
+      return true;
+    }
+    if (arrA != arrB)
+      return false;
+    const dateA = a instanceof Date, dateB = b instanceof Date;
+    if (dateA != dateB)
+      return false;
+    if (dateA && dateB)
+      return a.getTime() == b.getTime();
+    const regexpA = a instanceof RegExp, regexpB = b instanceof RegExp;
+    if (regexpA != regexpB)
+      return false;
+    if (regexpA && regexpB)
+      return a.toString() == b.toString();
+    const keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    for (i = length; i-- !== 0; ) {
+      key = keys[i];
+      if (!deepEquals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+function resolveFieldData(data, field) {
+  if (data && Object.keys(data).length && field) {
+    if (field.indexOf(".") === -1) {
+      return data[field];
+    } else {
+      const fields = field.split(".");
+      let value = data;
+      for (let i = 0, len = fields.length; i < len; ++i) {
+        if (data == null) {
+          return null;
+        }
+        value = value[fields[i]];
+      }
+      return value;
+    }
+  } else {
+    return null;
+  }
+}
+function contains(value, list) {
+  if (value != null && list && list.length) {
+    for (const val of list) {
+      if (equals(value, val)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isEmpty(value) {
+  return ((value2) => value2 === null || value2 === void 0 || value2 === "" || Array.isArray(value2) && value2.length === 0 || !(value2 instanceof Date) && typeof value2 === "object" && Object.keys(value2).length === 0)(unref(value));
+}
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+function useInjectedGroupState(groupKey) {
+  const group = inject(groupKey, void 0);
+  const isInGroup = computed(() => !isEmpty(group));
+  function getGroupOrLocalRef(propName, props, emit) {
+    if (group == null ? void 0 : group.value) {
+      const groupPropValue = unref(group.value)[propName];
+      return computed({
+        get() {
+          return groupPropValue == null ? void 0 : groupPropValue.value;
+        },
+        set(value) {
+          groupPropValue.value = value;
+        }
+      });
+    }
+    const propRef = toRef(props, propName);
+    return computed({
+      get() {
+        return propRef.value;
+      },
+      set(value) {
+        if (emit)
+          emit(`update:${propName}`, value);
+      }
+    });
+  }
+  return {
+    group,
+    isInGroup,
+    getGroupOrLocalRef
+  };
+}
+const VvButtonEvents = ["update:modelValue"];
+const VvButtonProps = {
+  ...ActionProps,
+  ...IdProps,
+  ...ModifiersProps,
+  ...UnselectableProps,
+  ...LoadingProps,
+  /**
+   * Button icon
+   */
+  icon: [String, Object],
+  /**
+   * Button icon position
+   */
+  iconPosition: {
+    type: String,
+    default: Side.left,
+    validator: (value) => Object.values(Side).includes(value)
+  },
+  /**
+   * Loading icon
+   */
+  loadingIcon: { type: String, default: "eos-icons:bubble-loading" },
+  /**
+   * Enable button toggle
+   */
+  toggle: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * Button toggle value
+   */
+  value: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  /**
+   * Value associated with the unchecked state
+   */
+  uncheckedValue: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  /**
+   * Button toggle model value
+   */
+  modelValue: {
+    type: [String, Number, Boolean],
+    default: void 0
+  }
+};
+function useGroupProps(props, emit) {
+  const { group, isInGroup, getGroupOrLocalRef } = useInjectedGroupState(INJECTION_KEY_BUTTON_GROUP);
+  const { id, iconPosition, icon, label, pressed } = toRefs(props);
+  const modelValue = getGroupOrLocalRef("modelValue", props, emit);
+  const toggle = getGroupOrLocalRef("toggle", props);
+  const unselectable = getGroupOrLocalRef(
+    "unselectable",
+    props
+  );
+  const multiple = computed(() => (group == null ? void 0 : group.value.multiple.value) ?? false);
+  const modifiers = computed(() => {
+    let localModifiers = props.modifiers;
+    let groupModifiers = group == null ? void 0 : group.value.modifiers.value;
+    const toReturn = /* @__PURE__ */ new Set();
+    if (localModifiers) {
+      if (!Array.isArray(localModifiers)) {
+        localModifiers = localModifiers.split(" ");
+      }
+      localModifiers.forEach((modifier) => toReturn.add(modifier));
+    }
+    if (groupModifiers) {
+      if (!Array.isArray(groupModifiers)) {
+        groupModifiers = groupModifiers.split(" ");
+      }
+      groupModifiers.forEach((modifier) => toReturn.add(modifier));
+    }
+    return Array.from(toReturn);
+  });
+  const disabled = computed(
+    () => {
+      var _a;
+      return Boolean(props.disabled || ((_a = group == null ? void 0 : group.value) == null ? void 0 : _a.disabled.value));
+    }
+  );
+  return {
+    // group props
+    group,
+    isInGroup,
+    modelValue,
+    toggle,
+    unselectable,
+    multiple,
+    modifiers,
+    disabled,
+    // local props
+    id,
+    pressed,
+    iconPosition,
+    icon,
+    label
+  };
+}
+const useUniqueId = (id) => computed(() => String((id == null ? void 0 : id.value) || uid()));
+const _hoisted_1$1 = {
+  key: 1,
+  class: "vv-button__label"
+};
+const _hoisted_2$1 = {
+  key: 1,
+  class: "vv-button__label"
+};
+const __default__$1 = {
+  name: "VvButton"
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...__default__$1,
+  props: VvButtonProps,
+  emits: VvButtonEvents,
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const attrs = useAttrs();
+    const slots = useSlots();
+    const {
+      id,
+      modifiers,
+      iconPosition,
+      icon,
+      label,
+      modelValue,
+      disabled,
+      toggle,
+      unselectable
+    } = useGroupProps(props, emit);
+    const hasId = useUniqueId(id);
+    const name = computed(() => (attrs == null ? void 0 : attrs.name) || hasId.value);
+    const element = ref(null);
+    const $el = computed(() => {
+      var _a;
+      return (_a = element.value) == null ? void 0 : _a.$el;
+    });
+    __expose({ $el });
+    const pressed = computed(() => {
+      if (!toggle.value) {
+        return props.pressed;
+      }
+      if (Array.isArray(modelValue.value)) {
+        return contains(name.value, modelValue.value);
+      }
+      return equals(name.value, modelValue.value);
+    });
+    const bemCssClasses = useModifiers(
+      "vv-button",
+      modifiers,
+      computed(() => ({
+        reverse: [Side.right, Side.bottom].includes(
+          iconPosition.value
+        ),
+        column: [Side.top, Side.bottom].includes(
+          iconPosition.value
+        ),
+        "icon-only": Boolean(
+          (icon == null ? void 0 : icon.value) && !(label == null ? void 0 : label.value) && !slots.default
+        )
+      }))
+    );
+    const hasIconProps = computed(
+      () => typeof (icon == null ? void 0 : icon.value) === "string" ? { name: icon == null ? void 0 : icon.value } : icon == null ? void 0 : icon.value
+    );
+    const toggleValue = computed(() => {
+      return props.value !== void 0 ? props.value : name.value;
+    });
+    const onClick = () => {
+      if (toggle.value) {
+        if (Array.isArray(modelValue.value)) {
+          if (contains(toggleValue.value, modelValue.value)) {
+            if (unselectable.value) {
+              modelValue.value = modelValue.value.filter(
+                (n) => n !== toggleValue.value
+              );
+            }
+            return;
+          }
+          modelValue.value.push(toggleValue.value);
+          return;
+        }
+        if (toggleValue.value === modelValue.value && unselectable.value) {
+          modelValue.value = props.uncheckedValue;
+          return;
+        }
+        modelValue.value = toggleValue.value;
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$2, mergeProps({
+        disabled: unref(disabled),
+        pressed: unref(pressed),
+        active: _ctx.active,
+        type: _ctx.type,
+        to: _ctx.to,
+        href: _ctx.href,
+        target: _ctx.target,
+        rel: _ctx.rel,
+        ariaLabel: _ctx.ariaLabel
+      }, {
+        id: unref(hasId),
+        ref_key: "element",
+        ref: element,
+        class: unref(bemCssClasses),
+        onClick
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            _ctx.loading ? renderSlot(_ctx.$slots, "loading", { key: 0 }, () => [
+              _ctx.loadingIcon ? (openBlock(), createBlock(_sfc_main$3, {
+                key: 0,
+                class: "vv-button__loading-icon",
+                name: _ctx.loadingIcon
+              }, null, 8, ["name"])) : createCommentVNode("v-if", true),
+              _ctx.loadingLabel ? (openBlock(), createElementBlock(
+                "span",
+                _hoisted_1$1,
+                toDisplayString(_ctx.loadingLabel),
+                1
+                /* TEXT */
+              )) : createCommentVNode("v-if", true)
+            ]) : (openBlock(), createElementBlock(
+              Fragment,
+              { key: 1 },
+              [
+                renderSlot(_ctx.$slots, "before"),
+                unref(icon) ? (openBlock(), createBlock(
+                  _sfc_main$3,
+                  mergeProps({
+                    key: 0,
+                    class: "vv-button__icon"
+                  }, unref(hasIconProps)),
+                  null,
+                  16
+                  /* FULL_PROPS */
+                )) : createCommentVNode("v-if", true),
+                unref(label) ? (openBlock(), createElementBlock("span", _hoisted_2$1, [
+                  renderSlot(_ctx.$slots, "label", {}, () => [
+                    createTextVNode(
+                      toDisplayString(unref(label)),
+                      1
+                      /* TEXT */
+                    )
+                  ])
+                ])) : createCommentVNode("v-if", true),
+                renderSlot(_ctx.$slots, "after")
+              ],
+              64
+              /* STABLE_FRAGMENT */
+            ))
+          ])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["id", "class"]);
+    };
+  }
+});
+function joinLines(items) {
+  if (Array.isArray(items)) {
+    return items.filter((item) => isString(item)).join(" ");
+  }
+  return items;
+}
+function HintSlotFactory(propsOrRef, slots) {
+  const props = computed(() => {
+    if (isRef(propsOrRef)) {
+      return propsOrRef.value;
+    }
+    return propsOrRef;
+  });
+  const invalidLabel = computed(() => joinLines(props.value.invalidLabel));
+  const validLabel = computed(() => joinLines(props.value.validLabel));
+  const loadingLabel = computed(() => props.value.loadingLabel);
+  const hintLabel = computed(() => props.value.hintLabel);
+  const hasLoadingLabelOrSlot = computed(
+    () => Boolean(props.value.loading && (slots.loading || loadingLabel.value))
+  );
+  const hasInvalidLabelOrSlot = computed(
+    () => !hasLoadingLabelOrSlot.value && Boolean(
+      props.value.invalid && (slots.invalid || invalidLabel.value)
+    )
+  );
+  const hasValidLabelOrSlot = computed(
+    () => !hasLoadingLabelOrSlot.value && !hasInvalidLabelOrSlot.value && Boolean(props.value.valid && (slots.valid || validLabel.value))
+  );
+  const hasHintLabelOrSlot = computed(
+    () => !hasLoadingLabelOrSlot.value && !hasInvalidLabelOrSlot.value && !hasValidLabelOrSlot.value && Boolean(slots.hint || hintLabel.value)
+  );
+  const isVisible = computed(
+    () => hasInvalidLabelOrSlot.value || hasValidLabelOrSlot.value || hasLoadingLabelOrSlot.value || hasHintLabelOrSlot.value
+  );
+  const hintSlotScope = computed(() => ({
+    modelValue: props.value.modelValue,
+    valid: props.value.valid,
+    invalid: props.value.invalid,
+    loading: props.value.loading
+  }));
+  const HintSlot = defineComponent({
+    name: "HintSlot",
+    props: {
+      tag: {
+        type: String,
+        default: "small"
+      }
+    },
+    setup() {
+      return {
+        isVisible,
+        invalidLabel,
+        validLabel,
+        loadingLabel,
+        hintLabel,
+        hasInvalidLabelOrSlot,
+        hasValidLabelOrSlot,
+        hasLoadingLabelOrSlot,
+        hasHintLabelOrSlot
+      };
+    },
+    render() {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      if (this.isVisible) {
+        let role;
+        if (this.hasInvalidLabelOrSlot) {
+          role = "alert";
+        }
+        if (this.hasValidLabelOrSlot) {
+          role = "status";
+        }
+        if (this.hasLoadingLabelOrSlot) {
+          return h(
+            this.tag,
+            {
+              role
+            },
+            ((_b = (_a = this.$slots).loading) == null ? void 0 : _b.call(_a)) ?? this.loadingLabel
+          );
+        }
+        if (this.hasInvalidLabelOrSlot) {
+          return h(
+            this.tag,
+            {
+              role
+            },
+            ((_d = (_c = this.$slots).invalid) == null ? void 0 : _d.call(_c)) ?? this.$slots.invalid ?? this.invalidLabel
+          );
+        }
+        if (this.hasValidLabelOrSlot) {
+          return h(
+            this.tag,
+            {
+              role
+            },
+            ((_f = (_e = this.$slots).valid) == null ? void 0 : _f.call(_e)) ?? this.validLabel
+          );
+        }
+        return h(
+          this.tag,
+          {
+            role
+          },
+          ((_h = (_g = this.$slots).hint) == null ? void 0 : _h.call(_g)) ?? this.$slots.hint ?? this.hintLabel
+        );
+      }
+      return null;
+    }
+  });
+  return {
+    hasInvalidLabelOrSlot,
+    hasHintLabelOrSlot,
+    hasValidLabelOrSlot,
+    hasLoadingLabelOrSlot,
+    hintSlotScope,
+    HintSlot
+  };
+}
+const VvInputFileProps = {
+  ...ModifiersProps,
+  ...ValidProps,
+  ...InvalidProps,
+  ...HintProps,
+  ...LabelProps,
+  ...LoadingProps,
+  name: { type: String },
+  id: { type: String },
+  modelValue: {
+    type: Object,
+    required: true
+  },
+  max: [Number, String],
+  labelButton: { type: String, default: "Image" },
+  loading: Boolean,
+  accept: String,
+  placeholder: String,
+  multiple: Boolean,
+  iconLeft: String,
+  iconRight: String
+};
+function useDefaults(componentName, propsDefinition, props) {
+  const volver = useVolver();
+  const volverComponentDefaults = computed(() => {
+    var _a;
+    if (!volver || !((_a = volver.defaults.value) == null ? void 0 : _a[componentName])) {
+      return void 0;
+    }
+    return volver.defaults.value[componentName];
+  });
+  return computed(() => {
+    if (volverComponentDefaults.value === void 0) {
+      return props;
+    }
+    const componentDefaults = volverComponentDefaults.value;
+    const simplifiedPropsDefinition = propsDefinition;
+    const simplifiedProps = props;
+    return Object.keys(simplifiedPropsDefinition).reduce((acc, key) => {
+      const propValue = simplifiedProps[key];
+      acc[key] = propValue;
+      if (key in componentDefaults) {
+        if (Array.isArray(simplifiedPropsDefinition[key])) {
+          const typeArray = simplifiedPropsDefinition[key];
+          if (typeArray.length) {
+            const typeFunction = typeArray[0];
+            if (typeFunction === propValue) {
+              acc[key] = componentDefaults[key];
+            }
+          }
+        }
+        if (typeof simplifiedPropsDefinition[key] === "function") {
+          const typeFunction = simplifiedPropsDefinition[key];
+          if (typeFunction() === propValue) {
+            acc[key] = componentDefaults[key];
+          }
+        }
+        if (typeof simplifiedPropsDefinition[key] === "object") {
+          let defaultValue = simplifiedPropsDefinition[key].default;
+          if (typeof defaultValue === "function") {
+            defaultValue = defaultValue();
+          }
+          if (typeof defaultValue === "object") {
+            if (JSON.stringify(defaultValue) === JSON.stringify(propValue)) {
+              acc[key] = componentDefaults[key];
+            }
+          } else if (defaultValue === propValue) {
+            acc[key] = componentDefaults[key];
+          }
+        }
+      }
+      return acc;
+    }, {});
+  });
+}
+const _hoisted_1 = ["for"];
+const _hoisted_2 = ["onDragenter", "onDragleave", "onDrop", "onClick"];
+const _hoisted_3 = { class: "vv-input-file__preview" };
+const _hoisted_4 = ["src", "alt"];
+const _hoisted_5 = { class: "vv-input-file__wrapper" };
+const _hoisted_6 = ["id", "placeholder", "aria-describedby", "aria-invalid", "aria-errormessage", "multiple", "accept", "name"];
+const _hoisted_7 = { class: "vv-input-file__list" };
+const _hoisted_8 = { class: "vv-input-file__item-name" };
+const _hoisted_9 = { class: "vv-input-file__item-info" };
+const _hoisted_10 = ["onClick"];
+const __default__ = {
+  name: "VvInputFile"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: VvInputFileProps,
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const slots = useSlots();
+    const propsDefaults = useDefaults(
+      "VvInputFile",
+      VvInputFileProps,
+      props
+    );
+    const { modifiers, id } = toRefs(props);
+    const hasId = useUniqueId(id);
+    const hasHintId = computed(() => `${hasId.value}-hint`);
+    const bemCssClasses = useModifiers(
+      "vv-input-file",
+      modifiers,
+      computed(() => ({
+        dragging: isDragging.value,
+        loading: props.loading,
+        valid: props.valid === true,
+        invalid: props.invalid === true,
+        "icon-before": !!props.iconLeft,
+        "icon-after": !!props.iconRight
+      }))
+    );
+    const {
+      HintSlot,
+      hasHintLabelOrSlot,
+      hasInvalidLabelOrSlot,
+      hintSlotScope
+    } = HintSlotFactory(propsDefaults, slots);
+    const localModelValue = useVModel(props, "modelValue", emit);
+    const files = computed(() => {
+      var _a;
+      if (!localModelValue.value || !Array.isArray(localModelValue.value) && !((_a = localModelValue.value) == null ? void 0 : _a.name)) {
+        return [];
+      }
+      return Array.isArray(localModelValue.value) ? localModelValue.value : [localModelValue.value];
+    });
+    const hasMax = computed(() => {
+      return typeof props.max === "string" ? parseInt(props.max) : props.max;
+    });
+    const hasDropArea = computed(() => {
+      var _a;
+      return (_a = modifiers == null ? void 0 : modifiers.value) == null ? void 0 : _a.includes("drop-area");
+    });
+    const isMultiple = computed(() => {
+      if (!props.multiple) {
+        return false;
+      }
+      if (!hasMax.value) {
+        return true;
+      }
+      return hasMax.value - files.value.length > 1;
+    });
+    const isDragging = ref(false);
+    const inputEl = ref();
+    const onDragenter = () => {
+      isDragging.value = true;
+    };
+    const onDragleave = () => {
+      isDragging.value = false;
+    };
+    const onDrop = (event) => {
+      var _a, _b;
+      if (!((_a = event.dataTransfer) == null ? void 0 : _a.files)) {
+        return;
+      }
+      isDragging.value = false;
+      addFiles((_b = event.dataTransfer) == null ? void 0 : _b.files);
+    };
+    const onChange = () => {
+      var _a;
+      if (!((_a = inputEl.value) == null ? void 0 : _a.files)) {
+        return;
+      }
+      addFiles(inputEl.value.files);
+      inputEl.value.value = "";
+    };
+    const addFiles = (uploadedFiles) => {
+      if (!props.multiple) {
+        if (Array.isArray(localModelValue.value)) {
+          localModelValue.value = [...uploadedFiles];
+          return;
+        }
+        localModelValue.value = uploadedFiles[0];
+        return;
+      }
+      let toReturn = [];
+      if (!Array.isArray(localModelValue.value) && localModelValue.value) {
+        toReturn = [localModelValue.value];
+      } else {
+        toReturn = localModelValue.value && Array.isArray(localModelValue.value) ? [...localModelValue.value] : toReturn;
+      }
+      for (const file of uploadedFiles) {
+        if (hasMax.value && toReturn.length >= hasMax.value) {
+          break;
+        }
+        toReturn.push(file);
+      }
+      localModelValue.value = toReturn;
+    };
+    const onClick = () => {
+      if (!inputEl.value) {
+        return;
+      }
+      inputEl.value.click();
+    };
+    const onClickRemoveFile = (index) => {
+      if (!Array.isArray(localModelValue.value)) {
+        localModelValue.value = void 0;
+        return;
+      }
+      const toReturn = [...localModelValue.value];
+      toReturn.splice(index, 1);
+      localModelValue.value = toReturn;
+    };
+    const previewSrc = computed(() => {
+      if (files.value.length === 0) {
+        return;
+      }
+      if (files.value[0] instanceof File) {
+        return URL.createObjectURL(files.value[0]);
+      }
+      return files.value[0].url;
+    });
+    onBeforeUnmount(() => {
+      if (previewSrc.value) {
+        URL.revokeObjectURL(previewSrc.value);
+      }
+    });
+    const sizeInKiB = (size) => {
+      if (!size) {
+        return;
+      }
+      return Math.floor(size / 1024);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass(unref(bemCssClasses))
+        },
+        [
+          _ctx.label ? (openBlock(), createElementBlock("label", {
+            key: 0,
+            for: unref(hasId)
+          }, toDisplayString(_ctx.label), 9, _hoisted_1)) : createCommentVNode("v-if", true),
+          hasDropArea.value ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: "vv-input-file__drop-area",
+            onDragenter: withModifiers(onDragenter, ["prevent", "stop"]),
+            onDragleave: withModifiers(onDragleave, ["prevent", "stop"]),
+            onDrop: withModifiers(onDrop, ["prevent", "stop"]),
+            onDragover: _cache[0] || (_cache[0] = withModifiers(() => {
+            }, ["prevent", "stop"])),
+            onClick: withModifiers(onClick, ["stop"])
+          }, [
+            renderSlot(_ctx.$slots, "drop-area", {}, () => [
+              createVNode(_sfc_main$1, {
+                modifiers: "action",
+                "aria-label": "upload",
+                label: !previewSrc.value ? _ctx.labelButton : void 0,
+                class: normalizeClass([{
+                  "absolute top-8 right-8": previewSrc.value
+                }, "z-1"]),
+                icon: !previewSrc.value ? "image" : "edit",
+                onClick: withModifiers(onClick, ["stop"])
+              }, null, 8, ["label", "class", "icon", "onClick"]),
+              createElementVNode("picture", _hoisted_3, [
+                previewSrc.value ? (openBlock(), createElementBlock("img", {
+                  key: 0,
+                  src: previewSrc.value,
+                  alt: files.value[0].name
+                }, null, 8, _hoisted_4)) : createCommentVNode("v-if", true)
+              ])
+            ])
+          ], 40, _hoisted_2)) : createCommentVNode("v-if", true),
+          createElementVNode("div", _hoisted_5, [
+            _ctx.iconLeft ? (openBlock(), createBlock(_sfc_main$3, {
+              key: 0,
+              name: _ctx.iconLeft
+            }, null, 8, ["name"])) : createCommentVNode("v-if", true),
+            createElementVNode("input", {
+              id: unref(hasId),
+              ref_key: "inputEl",
+              ref: inputEl,
+              placeholder: _ctx.placeholder,
+              "aria-describedby": unref(hasHintLabelOrSlot) ? hasHintId.value : void 0,
+              "aria-invalid": _ctx.invalid,
+              "aria-errormessage": unref(hasInvalidLabelOrSlot) ? hasHintId.value : void 0,
+              multiple: isMultiple.value,
+              accept: _ctx.accept,
+              type: "file",
+              name: _ctx.name,
+              onChange
+            }, null, 40, _hoisted_6),
+            _ctx.iconRight ? (openBlock(), createBlock(_sfc_main$3, {
+              key: 1,
+              name: _ctx.iconRight
+            }, null, 8, ["name"])) : createCommentVNode("v-if", true)
+          ]),
+          createElementVNode("ul", _hoisted_7, [
+            (openBlock(true), createElementBlock(
+              Fragment,
+              null,
+              renderList(files.value, (file, index) => {
+                return openBlock(), createElementBlock("li", {
+                  key: index,
+                  class: "vv-input-file__item"
+                }, [
+                  createVNode(_sfc_main$3, {
+                    class: "vv-input-file__item-icon",
+                    name: "akar-icons:file"
+                  }),
+                  createElementVNode(
+                    "div",
+                    _hoisted_8,
+                    toDisplayString(file.name),
+                    1
+                    /* TEXT */
+                  ),
+                  createElementVNode(
+                    "small",
+                    _hoisted_9,
+                    toDisplayString(sizeInKiB(file.size)) + " KB ",
+                    1
+                    /* TEXT */
+                  ),
+                  createElementVNode("button", {
+                    type: "button",
+                    class: "vv-input-file__item-remove",
+                    title: "Remove",
+                    "aria-label": "remove-file",
+                    onClick: withModifiers(($event) => onClickRemoveFile(index), ["stop"])
+                  }, null, 8, _hoisted_10)
+                ]);
+              }),
+              128
+              /* KEYED_FRAGMENT */
+            ))
+          ]),
+          createVNode(unref(HintSlot), {
+            id: hasHintId.value,
+            class: "vv-input-file__hint"
+          }, createSlots({
+            _: 2
+            /* DYNAMIC */
+          }, [
+            _ctx.$slots.hint ? {
+              name: "hint",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "hint", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "0"
+            } : void 0,
+            _ctx.$slots.loading ? {
+              name: "loading",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "loading", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "1"
+            } : void 0,
+            _ctx.$slots.valid ? {
+              name: "valid",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "valid", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "2"
+            } : void 0,
+            _ctx.$slots.invalid ? {
+              name: "invalid",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "invalid", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "3"
+            } : void 0
+          ]), 1032, ["id"])
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+export {
+  _sfc_main as default
+};