@brumaombra/ui-vintage 0.1.0

package/dist/FocusScope-C3mcVwsf.js

@@ -0,0 +1,454 @@
+import { i as injectConfigProviderContext } from "./ConfigProvider-D2O0Jles.js";
+import { computed, ref, watch, nextTick, onUnmounted, defineComponent, reactive, watchEffect, openBlock, createBlock, unref, withCtx, renderSlot } from "vue";
+import { b as useEventListener, a as unrefElement } from "./index-C1_fxYhb.js";
+import { h as tryOnBeforeUnmount, j as createSharedComposable, i as isClient, k as isIOS, l as createGlobalState } from "./index-Dfi5ESP2.js";
+import { d as defu } from "./Teleport-CuUn4UkG.js";
+import { u as useForwardExpose } from "./useForwardExpose-CNVHwdF2.js";
+import { P as Primitive } from "./Primitive-D3IcFg81.js";
+function getActiveElement() {
+  let activeElement = document.activeElement;
+  if (activeElement == null) return null;
+  while (activeElement != null && activeElement.shadowRoot != null && activeElement.shadowRoot.activeElement != null) activeElement = activeElement.shadowRoot.activeElement;
+  return activeElement;
+}
+const useBodyLockStackCount = createSharedComposable(() => {
+  const map = ref(/* @__PURE__ */ new Map());
+  const initialOverflow = ref();
+  const locked = computed(() => {
+    for (const value of map.value.values()) if (value) return true;
+    return false;
+  });
+  const context = injectConfigProviderContext({ scrollBody: ref(true) });
+  let stopTouchMoveListener = null;
+  const resetBodyStyle = () => {
+    document.body.style.paddingRight = "";
+    document.body.style.marginRight = "";
+    document.body.style.pointerEvents = "";
+    document.documentElement.style.removeProperty("--scrollbar-width");
+    document.body.style.overflow = initialOverflow.value ?? "";
+    isIOS && (stopTouchMoveListener == null ? void 0 : stopTouchMoveListener());
+    initialOverflow.value = void 0;
+  };
+  watch(locked, (val, oldVal) => {
+    var _a;
+    if (!isClient) return;
+    if (!val) {
+      if (oldVal) resetBodyStyle();
+      return;
+    }
+    if (initialOverflow.value === void 0) initialOverflow.value = document.body.style.overflow;
+    const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    const defaultConfig = {
+      padding: verticalScrollbarWidth,
+      margin: 0
+    };
+    const config = ((_a = context.scrollBody) == null ? void 0 : _a.value) ? typeof context.scrollBody.value === "object" ? defu({
+      padding: context.scrollBody.value.padding === true ? verticalScrollbarWidth : context.scrollBody.value.padding,
+      margin: context.scrollBody.value.margin === true ? verticalScrollbarWidth : context.scrollBody.value.margin
+    }, defaultConfig) : defaultConfig : {
+      padding: 0,
+      margin: 0
+    };
+    if (verticalScrollbarWidth > 0) {
+      document.body.style.paddingRight = typeof config.padding === "number" ? `${config.padding}px` : String(config.padding);
+      document.body.style.marginRight = typeof config.margin === "number" ? `${config.margin}px` : String(config.margin);
+      document.documentElement.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+      document.body.style.overflow = "hidden";
+    }
+    if (isIOS) stopTouchMoveListener = useEventListener(document, "touchmove", (e) => preventDefault(e), { passive: false });
+    nextTick(() => {
+      if (!locked.value) return;
+      document.body.style.pointerEvents = "none";
+      document.body.style.overflow = "hidden";
+    });
+  }, {
+    immediate: true,
+    flush: "sync"
+  });
+  return map;
+});
+function useBodyScrollLock(initialState) {
+  const id = Math.random().toString(36).substring(2, 7);
+  const map = useBodyLockStackCount();
+  map.value.set(id, initialState ?? false);
+  const locked = computed({
+    get: () => map.value.get(id) ?? false,
+    set: (value) => map.value.set(id, value)
+  });
+  tryOnBeforeUnmount(() => {
+    map.value.delete(id);
+  });
+  return locked;
+}
+function checkOverflowScroll(ele) {
+  const style = window.getComputedStyle(ele);
+  if (style.overflowX === "scroll" || style.overflowY === "scroll" || style.overflowX === "auto" && ele.clientWidth < ele.scrollWidth || style.overflowY === "auto" && ele.clientHeight < ele.scrollHeight) return true;
+  else {
+    const parent = ele.parentNode;
+    if (!(parent instanceof Element) || parent.tagName === "BODY") return false;
+    return checkOverflowScroll(parent);
+  }
+}
+function preventDefault(rawEvent) {
+  const e = rawEvent || window.event;
+  const _target = e.target;
+  if (_target instanceof Element && checkOverflowScroll(_target)) return false;
+  if (e.touches.length > 1) return true;
+  if (e.preventDefault && e.cancelable) e.preventDefault();
+  return false;
+}
+var getDefaultParent = function(originalTarget) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
+  return sampleTarget.ownerDocument.body;
+};
+var counterMap = /* @__PURE__ */ new WeakMap();
+var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+var markerMap = {};
+var lockCount = 0;
+var unwrapHost = function(node) {
+  return node && (node.host || unwrapHost(node.parentNode));
+};
+var correctTargets = function(parent, targets) {
+  return targets.map(function(target) {
+    if (parent.contains(target)) {
+      return target;
+    }
+    var correctedTarget = unwrapHost(target);
+    if (correctedTarget && parent.contains(correctedTarget)) {
+      return correctedTarget;
+    }
+    console.error("aria-hidden", target, "in not contained inside", parent, ". Doing nothing");
+    return null;
+  }).filter(function(x) {
+    return Boolean(x);
+  });
+};
+var applyAttributeToOthers = function(originalTarget, parentNode, markerName, controlAttribute) {
+  var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+  if (!markerMap[markerName]) {
+    markerMap[markerName] = /* @__PURE__ */ new WeakMap();
+  }
+  var markerCounter = markerMap[markerName];
+  var hiddenNodes = [];
+  var elementsToKeep = /* @__PURE__ */ new Set();
+  var elementsToStop = new Set(targets);
+  var keep = function(el) {
+    if (!el || elementsToKeep.has(el)) {
+      return;
+    }
+    elementsToKeep.add(el);
+    keep(el.parentNode);
+  };
+  targets.forEach(keep);
+  var deep = function(parent) {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    Array.prototype.forEach.call(parent.children, function(node) {
+      if (elementsToKeep.has(node)) {
+        deep(node);
+      } else {
+        try {
+          var attr = node.getAttribute(controlAttribute);
+          var alreadyHidden = attr !== null && attr !== "false";
+          var counterValue = (counterMap.get(node) || 0) + 1;
+          var markerValue = (markerCounter.get(node) || 0) + 1;
+          counterMap.set(node, counterValue);
+          markerCounter.set(node, markerValue);
+          hiddenNodes.push(node);
+          if (counterValue === 1 && alreadyHidden) {
+            uncontrolledNodes.set(node, true);
+          }
+          if (markerValue === 1) {
+            node.setAttribute(markerName, "true");
+          }
+          if (!alreadyHidden) {
+            node.setAttribute(controlAttribute, "true");
+          }
+        } catch (e) {
+          console.error("aria-hidden: cannot operate on ", node, e);
+        }
+      }
+    });
+  };
+  deep(parentNode);
+  elementsToKeep.clear();
+  lockCount++;
+  return function() {
+    hiddenNodes.forEach(function(node) {
+      var counterValue = counterMap.get(node) - 1;
+      var markerValue = markerCounter.get(node) - 1;
+      counterMap.set(node, counterValue);
+      markerCounter.set(node, markerValue);
+      if (!counterValue) {
+        if (!uncontrolledNodes.has(node)) {
+          node.removeAttribute(controlAttribute);
+        }
+        uncontrolledNodes.delete(node);
+      }
+      if (!markerValue) {
+        node.removeAttribute(markerName);
+      }
+    });
+    lockCount--;
+    if (!lockCount) {
+      counterMap = /* @__PURE__ */ new WeakMap();
+      counterMap = /* @__PURE__ */ new WeakMap();
+      uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+      markerMap = {};
+    }
+  };
+};
+var hideOthers = function(originalTarget, parentNode, markerName) {
+  if (markerName === void 0) {
+    markerName = "data-aria-hidden";
+  }
+  var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+  var activeParentNode = getDefaultParent(originalTarget);
+  if (!activeParentNode) {
+    return function() {
+      return null;
+    };
+  }
+  targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live], script")));
+  return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
+};
+function useHideOthers(target) {
+  let undo;
+  watch(() => unrefElement(target), (el) => {
+    let isInsideClosedPopover = false;
+    try {
+      isInsideClosedPopover = !!(el == null ? void 0 : el.closest("[popover]:not(:popover-open)"));
+    } catch {
+    }
+    if (el && !isInsideClosedPopover) undo = hideOthers(el);
+    else if (undo) undo();
+  });
+  onUnmounted(() => {
+    if (undo) undo();
+  });
+}
+const useFocusStackState = createGlobalState(() => {
+  const stack = ref([]);
+  return stack;
+});
+function createFocusScopesStack() {
+  const stack = useFocusStackState();
+  return {
+    add(focusScope) {
+      const activeFocusScope = stack.value[0];
+      if (focusScope !== activeFocusScope) activeFocusScope == null ? void 0 : activeFocusScope.pause();
+      stack.value = arrayRemove(stack.value, focusScope);
+      stack.value.unshift(focusScope);
+    },
+    remove(focusScope) {
+      var _a;
+      stack.value = arrayRemove(stack.value, focusScope);
+      (_a = stack.value[0]) == null ? void 0 : _a.resume();
+    }
+  };
+}
+function arrayRemove(array, item) {
+  const updatedArray = [...array];
+  const index = updatedArray.indexOf(item);
+  if (index !== -1) updatedArray.splice(index, 1);
+  return updatedArray;
+}
+const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+const AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+const EVENT_OPTIONS = {
+  bubbles: false,
+  cancelable: true
+};
+function focusFirst(candidates, { select = false } = {}) {
+  const previouslyFocusedElement = getActiveElement();
+  for (const candidate of candidates) {
+    focus(candidate, { select });
+    if (getActiveElement() !== previouslyFocusedElement) return true;
+  }
+}
+function getTabbableEdges(container) {
+  const candidates = getTabbableCandidates(container);
+  const first = findVisible(candidates, container);
+  const last = findVisible(candidates.reverse(), container);
+  return [first, last];
+}
+function getTabbableCandidates(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, { acceptNode: (node) => {
+    const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+    if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+    return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+  } });
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  return nodes;
+}
+function findVisible(elements, container) {
+  for (const element of elements) if (!isHidden(element, { upTo: container })) return element;
+}
+function isHidden(node, { upTo }) {
+  if (getComputedStyle(node).visibility === "hidden") return true;
+  while (node) {
+    if (upTo !== void 0 && node === upTo) return false;
+    if (getComputedStyle(node).display === "none") return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+function isSelectableInput(element) {
+  return element instanceof HTMLInputElement && "select" in element;
+}
+function focus(element, { select = false } = {}) {
+  if (element && element.focus) {
+    const previouslyFocusedElement = getActiveElement();
+    element.focus({ preventScroll: true });
+    if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
+  }
+}
+var FocusScope_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "FocusScope",
+  props: {
+    loop: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    trapped: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: ["mountAutoFocus", "unmountAutoFocus"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { currentRef, currentElement } = useForwardExpose();
+    const lastFocusedElementRef = ref(null);
+    const focusScopesStack = createFocusScopesStack();
+    const focusScope = reactive({
+      paused: false,
+      pause() {
+        this.paused = true;
+      },
+      resume() {
+        this.paused = false;
+      }
+    });
+    watchEffect((cleanupFn) => {
+      if (!isClient) return;
+      const container = currentElement.value;
+      if (!props.trapped) return;
+      function handleFocusIn(event) {
+        if (focusScope.paused || !container) return;
+        const target = event.target;
+        if (container.contains(target)) lastFocusedElementRef.value = target;
+        else focus(lastFocusedElementRef.value, { select: true });
+      }
+      function handleFocusOut(event) {
+        if (focusScope.paused || !container) return;
+        const relatedTarget = event.relatedTarget;
+        if (relatedTarget === null) return;
+        if (!container.contains(relatedTarget)) focus(lastFocusedElementRef.value, { select: true });
+      }
+      function handleMutations(mutations) {
+        const isLastFocusedElementExist = container.contains(lastFocusedElementRef.value);
+        if (!isLastFocusedElementExist) focus(container);
+      }
+      document.addEventListener("focusin", handleFocusIn);
+      document.addEventListener("focusout", handleFocusOut);
+      const mutationObserver = new MutationObserver(handleMutations);
+      if (container) mutationObserver.observe(container, {
+        childList: true,
+        subtree: true
+      });
+      cleanupFn(() => {
+        document.removeEventListener("focusin", handleFocusIn);
+        document.removeEventListener("focusout", handleFocusOut);
+        mutationObserver.disconnect();
+      });
+    });
+    watchEffect(async (cleanupFn) => {
+      const container = currentElement.value;
+      await nextTick();
+      if (!container) return;
+      focusScopesStack.add(focusScope);
+      const previouslyFocusedElement = getActiveElement();
+      const hasFocusedCandidate = container.contains(previouslyFocusedElement);
+      if (!hasFocusedCandidate) {
+        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+        container.addEventListener(AUTOFOCUS_ON_MOUNT, (ev) => emits("mountAutoFocus", ev));
+        container.dispatchEvent(mountEvent);
+        if (!mountEvent.defaultPrevented) {
+          focusFirst(getTabbableCandidates(container), { select: true });
+          if (getActiveElement() === previouslyFocusedElement) focus(container);
+        }
+      }
+      cleanupFn(() => {
+        container.removeEventListener(AUTOFOCUS_ON_MOUNT, (ev) => emits("mountAutoFocus", ev));
+        const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+        const unmountEventHandler = (ev) => {
+          emits("unmountAutoFocus", ev);
+        };
+        container.addEventListener(AUTOFOCUS_ON_UNMOUNT, unmountEventHandler);
+        container.dispatchEvent(unmountEvent);
+        setTimeout(() => {
+          if (!unmountEvent.defaultPrevented) focus(previouslyFocusedElement ?? document.body, { select: true });
+          container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, unmountEventHandler);
+          focusScopesStack.remove(focusScope);
+        }, 0);
+      });
+    });
+    function handleKeyDown(event) {
+      if (!props.loop && !props.trapped) return;
+      if (focusScope.paused) return;
+      const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+      const focusedElement = getActiveElement();
+      if (isTabKey && focusedElement) {
+        const container = event.currentTarget;
+        const [first, last] = getTabbableEdges(container);
+        const hasTabbableElementsInside = first && last;
+        if (!hasTabbableElementsInside) {
+          if (focusedElement === container) event.preventDefault();
+        } else if (!event.shiftKey && focusedElement === last) {
+          event.preventDefault();
+          if (props.loop) focus(first, { select: true });
+        } else if (event.shiftKey && focusedElement === first) {
+          event.preventDefault();
+          if (props.loop) focus(last, { select: true });
+        }
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        ref_key: "currentRef",
+        ref: currentRef,
+        tabindex: "-1",
+        "as-child": _ctx.asChild,
+        as: _ctx.as,
+        onKeydown: handleKeyDown
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, ["as-child", "as"]);
+    };
+  }
+});
+var FocusScope_default = FocusScope_vue_vue_type_script_setup_true_lang_default;
+export {
+  FocusScope_default as F,
+  useHideOthers as a,
+  getActiveElement as g,
+  useBodyScrollLock as u
+};

package/dist/Input.vue_vue_type_script_setup_true_lang-U778IWa0.js

@@ -0,0 +1,37 @@
+import { defineComponent, withDirectives, openBlock, createElementBlock, normalizeClass, unref, isRef, vModelText } from "vue";
+import { u as useVModel } from "./index-C1_fxYhb.js";
+import { c as cn } from "./utils-Bz4m9VPB.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Input",
+  props: {
+    defaultValue: {},
+    modelValue: {},
+    class: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const modelValue = useVModel(props, "modelValue", emits, {
+      passive: true,
+      defaultValue: props.defaultValue
+    });
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createElementBlock("input", {
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(modelValue) ? modelValue.value = $event : null),
+        "data-slot": "input",
+        class: normalizeClass(unref(cn)(
+          "file:text-foreground selection:bg-primary selection:text-primary-foreground h-[52px] w-full min-w-0 rounded border border-(--border-light) bg-(--button-secondary-light) px-4 py-3 text-xs font-medium text-(--text-primary-light) outline-none transition-all duration-300 ease-in-out placeholder:text-(--text-secondary-light) placeholder:opacity-60 file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-60 dark:border-(--border-dark) dark:bg-(--button-secondary-dark) dark:text-(--text-primary-dark) dark:placeholder:text-(--text-secondary-dark) sm:text-sm",
+          "focus-visible:border-(--border-hover-light) focus-visible:ring-0 dark:focus-visible:border-(--border-hover-dark)",
+          "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+          props.class
+        ))
+      }, null, 2)), [
+        [vModelText, unref(modelValue)]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/Label.vue_vue_type_script_setup_true_lang-B_fwvfJ-.js

@@ -0,0 +1,65 @@
+import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import { u as useForwardExpose } from "./useForwardExpose-CNVHwdF2.js";
+import { P as Primitive } from "./Primitive-D3IcFg81.js";
+import { c as cn } from "./utils-Bz4m9VPB.js";
+import { r as reactiveOmit } from "./index-Dfi5ESP2.js";
+var Label_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "Label",
+  props: {
+    for: {
+      type: String,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "label"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, { onMousedown: _cache[0] || (_cache[0] = (event) => {
+        if (!event.defaultPrevented && event.detail > 1) event.preventDefault();
+      }) }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+var Label_default = Label_vue_vue_type_script_setup_true_lang_default;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Label",
+  props: {
+    for: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = reactiveOmit(props, "class");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Label_default), mergeProps({ "data-slot": "label" }, unref(delegatedProps), {
+        class: unref(cn)(
+          "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+          props.class
+        )
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/MessageDialog-BrowppID.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "./MessageDialog.vue_vue_type_script_setup_true_lang-Ddih5Isd.js";
+export {
+  _sfc_main as default
+};