@brumaombra/ui-vintage 0.1.0

package/dist/Teleport-CuUn4UkG.js

@@ -0,0 +1,493 @@
+import { i as injectConfigProviderContext } from "./ConfigProvider-D2O0Jles.js";
+import * as vue from "vue";
+import { ref, watch, nextTick, onUnmounted, computed, defineComponent, toRefs, getCurrentInstance, h, watchEffect, toValue, openBlock, createBlock, unref, normalizeStyle, withCtx, renderSlot, reactive, Teleport, createCommentVNode } from "vue";
+import { r as renderSlotFragments, P as Primitive } from "./Primitive-D3IcFg81.js";
+import { d as defaultWindow, a as unrefElement, o as onKeyStroke, c as useMounted } from "./index-C1_fxYhb.js";
+import { i as isClient } from "./index-Dfi5ESP2.js";
+import { u as useForwardExpose } from "./useForwardExpose-CNVHwdF2.js";
+function handleAndDispatchCustomEvent(name, handler, detail) {
+  const target = detail.originalEvent.target;
+  const event = new CustomEvent(name, {
+    bubbles: false,
+    cancelable: true,
+    detail
+  });
+  if (handler) target.addEventListener(name, handler, { once: true });
+  target.dispatchEvent(event);
+}
+function isNullish(value) {
+  return value === null || value === void 0;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = { ...defaults };
+  for (const key of Object.keys(baseObject)) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
+let count = 0;
+function useId(deterministicId, prefix = "reka") {
+  var _a, _b;
+  let id;
+  if ("useId" in vue) id = (_a = vue.useId) == null ? void 0 : _a.call(vue);
+  else {
+    const configProviderContext = injectConfigProviderContext({ useId: void 0 });
+    id = ((_b = configProviderContext.useId) == null ? void 0 : _b.call(configProviderContext)) ?? `${++count}`;
+  }
+  return prefix ? `${prefix}-${id}` : id;
+}
+function useStateMachine(initialState, machine) {
+  const state = ref(initialState);
+  function reducer(event) {
+    const nextState = machine[state.value][event];
+    return nextState ?? state.value;
+  }
+  const dispatch = (event) => {
+    state.value = reducer(event);
+  };
+  return {
+    state,
+    dispatch
+  };
+}
+function usePresence(present, node) {
+  var _a;
+  const stylesRef = ref({});
+  const prevAnimationNameRef = ref("none");
+  const prevPresentRef = ref(present);
+  const initialState = present.value ? "mounted" : "unmounted";
+  let timeoutId;
+  const ownerWindow = ((_a = node.value) == null ? void 0 : _a.ownerDocument.defaultView) ?? defaultWindow;
+  const { state, dispatch } = useStateMachine(initialState, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: { MOUNT: "mounted" }
+  });
+  const dispatchCustomEvent = (name) => {
+    var _a2;
+    if (isClient) {
+      const customEvent = new CustomEvent(name, {
+        bubbles: false,
+        cancelable: false
+      });
+      (_a2 = node.value) == null ? void 0 : _a2.dispatchEvent(customEvent);
+    }
+  };
+  watch(present, async (currentPresent, prevPresent) => {
+    var _a2;
+    const hasPresentChanged = prevPresent !== currentPresent;
+    await nextTick();
+    if (hasPresentChanged) {
+      const prevAnimationName = prevAnimationNameRef.value;
+      const currentAnimationName = getAnimationName(node.value);
+      if (currentPresent) {
+        dispatch("MOUNT");
+        dispatchCustomEvent("enter");
+        if (currentAnimationName === "none") dispatchCustomEvent("after-enter");
+      } else if (currentAnimationName === "none" || currentAnimationName === "undefined" || ((_a2 = stylesRef.value) == null ? void 0 : _a2.display) === "none") {
+        dispatch("UNMOUNT");
+        dispatchCustomEvent("leave");
+        dispatchCustomEvent("after-leave");
+      } else {
+        const isAnimating = prevAnimationName !== currentAnimationName;
+        if (prevPresent && isAnimating) {
+          dispatch("ANIMATION_OUT");
+          dispatchCustomEvent("leave");
+        } else {
+          dispatch("UNMOUNT");
+          dispatchCustomEvent("after-leave");
+        }
+      }
+    }
+  }, { immediate: true });
+  const handleAnimationEnd = (event) => {
+    const currentAnimationName = getAnimationName(node.value);
+    const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
+    const directionName = state.value === "mounted" ? "enter" : "leave";
+    if (event.target === node.value && isCurrentAnimation) {
+      dispatchCustomEvent(`after-${directionName}`);
+      dispatch("ANIMATION_END");
+      if (!prevPresentRef.value) {
+        const currentFillMode = node.value.style.animationFillMode;
+        node.value.style.animationFillMode = "forwards";
+        timeoutId = ownerWindow == null ? void 0 : ownerWindow.setTimeout(() => {
+          var _a2;
+          if (((_a2 = node.value) == null ? void 0 : _a2.style.animationFillMode) === "forwards") node.value.style.animationFillMode = currentFillMode;
+        });
+      }
+    }
+    if (event.target === node.value && currentAnimationName === "none") dispatch("ANIMATION_END");
+  };
+  const handleAnimationStart = (event) => {
+    if (event.target === node.value) prevAnimationNameRef.value = getAnimationName(node.value);
+  };
+  const watcher = watch(node, (newNode, oldNode) => {
+    if (newNode) {
+      stylesRef.value = getComputedStyle(newNode);
+      newNode.addEventListener("animationstart", handleAnimationStart);
+      newNode.addEventListener("animationcancel", handleAnimationEnd);
+      newNode.addEventListener("animationend", handleAnimationEnd);
+    } else {
+      dispatch("ANIMATION_END");
+      if (timeoutId !== void 0) ownerWindow == null ? void 0 : ownerWindow.clearTimeout(timeoutId);
+      oldNode == null ? void 0 : oldNode.removeEventListener("animationstart", handleAnimationStart);
+      oldNode == null ? void 0 : oldNode.removeEventListener("animationcancel", handleAnimationEnd);
+      oldNode == null ? void 0 : oldNode.removeEventListener("animationend", handleAnimationEnd);
+    }
+  }, { immediate: true });
+  const stateWatcher = watch(state, () => {
+    const currentAnimationName = getAnimationName(node.value);
+    prevAnimationNameRef.value = state.value === "mounted" ? currentAnimationName : "none";
+  });
+  onUnmounted(() => {
+    watcher();
+    stateWatcher();
+  });
+  const isPresent = computed(() => ["mounted", "unmountSuspended"].includes(state.value));
+  return { isPresent };
+}
+function getAnimationName(node) {
+  return node ? getComputedStyle(node).animationName || "none" : "none";
+}
+var Presence_default = defineComponent({
+  name: "Presence",
+  props: {
+    present: {
+      type: Boolean,
+      required: true
+    },
+    forceMount: { type: Boolean }
+  },
+  slots: {},
+  setup(props, { slots, expose }) {
+    var _a;
+    const { present, forceMount } = toRefs(props);
+    const node = ref();
+    const { isPresent } = usePresence(present, node);
+    expose({ present: isPresent });
+    let children = slots.default({ present: isPresent.value });
+    children = renderSlotFragments(children || []);
+    const instance = getCurrentInstance();
+    if (children && (children == null ? void 0 : children.length) > 1) {
+      const componentName = ((_a = instance == null ? void 0 : instance.parent) == null ? void 0 : _a.type.name) ? `<${instance.parent.type.name} />` : "component";
+      throw new Error([
+        `Detected an invalid children for \`${componentName}\` for  \`Presence\` component.`,
+        "",
+        "Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",
+        "You can apply a few solutions:",
+        ["Provide a single child element so that `presence` directive attach correctly.", "Ensure the first child is an actual element instead of a raw text node or comment node."].map((line) => `  - ${line}`).join("\n")
+      ].join("\n"));
+    }
+    return () => {
+      if (forceMount.value || present.value || isPresent.value) return h(slots.default({ present: isPresent.value })[0], { ref: (v) => {
+        const el = unrefElement(v);
+        if (typeof (el == null ? void 0 : el.hasAttribute) === "undefined") return el;
+        if (el == null ? void 0 : el.hasAttribute("data-reka-popper-content-wrapper")) node.value = el.firstElementChild;
+        else node.value = el;
+        return el;
+      } });
+      else return null;
+    };
+  }
+});
+const POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+const FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+function isLayerExist(layerElement, targetElement) {
+  if (!(targetElement instanceof Element)) return false;
+  const targetLayer = targetElement.closest("[data-dismissable-layer]");
+  const mainLayer = layerElement.dataset.dismissableLayer === "" ? layerElement : layerElement.querySelector("[data-dismissable-layer]");
+  const nodeList = Array.from(layerElement.ownerDocument.querySelectorAll("[data-dismissable-layer]"));
+  if (targetLayer && (mainLayer === targetLayer || nodeList.indexOf(mainLayer) < nodeList.indexOf(targetLayer))) return true;
+  else return false;
+}
+function usePointerDownOutside(onPointerDownOutside, element, enabled = true) {
+  var _a;
+  const ownerDocument = ((_a = element == null ? void 0 : element.value) == null ? void 0 : _a.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document);
+  const isPointerInsideDOMTree = ref(false);
+  const handleClickRef = ref(() => {
+  });
+  watchEffect((cleanupFn) => {
+    if (!isClient || !toValue(enabled)) return;
+    const handlePointerDown = async (event) => {
+      const target = event.target;
+      if (!(element == null ? void 0 : element.value) || !target) return;
+      if (isLayerExist(element.value, target)) {
+        isPointerInsideDOMTree.value = false;
+        return;
+      }
+      if (event.target && !isPointerInsideDOMTree.value) {
+        let handleAndDispatchPointerDownOutsideEvent = function() {
+          handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, onPointerDownOutside, eventDetail);
+        };
+        const eventDetail = { originalEvent: event };
+        if (event.pointerType === "touch") {
+          ownerDocument.removeEventListener("click", handleClickRef.value);
+          handleClickRef.value = handleAndDispatchPointerDownOutsideEvent;
+          ownerDocument.addEventListener("click", handleClickRef.value, { once: true });
+        } else handleAndDispatchPointerDownOutsideEvent();
+      } else ownerDocument.removeEventListener("click", handleClickRef.value);
+      isPointerInsideDOMTree.value = false;
+    };
+    const timerId = window.setTimeout(() => {
+      ownerDocument.addEventListener("pointerdown", handlePointerDown);
+    }, 0);
+    cleanupFn(() => {
+      window.clearTimeout(timerId);
+      ownerDocument.removeEventListener("pointerdown", handlePointerDown);
+      ownerDocument.removeEventListener("click", handleClickRef.value);
+    });
+  });
+  return { onPointerDownCapture: () => {
+    if (!toValue(enabled)) return;
+    isPointerInsideDOMTree.value = true;
+  } };
+}
+function useFocusOutside(onFocusOutside, element, enabled = true) {
+  var _a;
+  const ownerDocument = ((_a = element == null ? void 0 : element.value) == null ? void 0 : _a.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document);
+  const isFocusInsideDOMTree = ref(false);
+  watchEffect((cleanupFn) => {
+    if (!isClient || !toValue(enabled)) return;
+    const handleFocus = async (event) => {
+      if (!(element == null ? void 0 : element.value)) return;
+      await nextTick();
+      await nextTick();
+      const target = event.target;
+      if (!element.value || !target || isLayerExist(element.value, target)) return;
+      if (event.target && !isFocusInsideDOMTree.value) {
+        const eventDetail = { originalEvent: event };
+        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, onFocusOutside, eventDetail);
+      }
+    };
+    ownerDocument.addEventListener("focusin", handleFocus);
+    cleanupFn(() => ownerDocument.removeEventListener("focusin", handleFocus));
+  });
+  return {
+    onFocusCapture: () => {
+      if (!toValue(enabled)) return;
+      isFocusInsideDOMTree.value = true;
+    },
+    onBlurCapture: () => {
+      if (!toValue(enabled)) return;
+      isFocusInsideDOMTree.value = false;
+    }
+  };
+}
+const context = reactive({
+  layersRoot: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  originalBodyPointerEvents: void 0,
+  branches: /* @__PURE__ */ new Set()
+});
+var DismissableLayer_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DismissableLayer",
+  props: {
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "dismiss"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { forwardRef, currentElement: layerElement } = useForwardExpose();
+    const ownerDocument = computed(() => {
+      var _a;
+      return ((_a = layerElement.value) == null ? void 0 : _a.ownerDocument) ?? globalThis.document;
+    });
+    const layers = computed(() => context.layersRoot);
+    const index = computed(() => {
+      return layerElement.value ? Array.from(layers.value).indexOf(layerElement.value) : -1;
+    });
+    const isBodyPointerEventsDisabled = computed(() => {
+      return context.layersWithOutsidePointerEventsDisabled.size > 0;
+    });
+    const isPointerEventsEnabled = computed(() => {
+      const localLayers = Array.from(layers.value);
+      const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+      const highestLayerWithOutsidePointerEventsDisabledIndex = localLayers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
+      return index.value >= highestLayerWithOutsidePointerEventsDisabledIndex;
+    });
+    const pointerDownOutside = usePointerDownOutside(async (event) => {
+      const isPointerDownOnBranch = [...context.branches].some((branch) => branch == null ? void 0 : branch.contains(event.target));
+      if (!isPointerEventsEnabled.value || isPointerDownOnBranch) return;
+      emits("pointerDownOutside", event);
+      emits("interactOutside", event);
+      await nextTick();
+      if (!event.defaultPrevented) emits("dismiss");
+    }, layerElement);
+    const focusOutside = useFocusOutside((event) => {
+      const isFocusInBranch = [...context.branches].some((branch) => branch == null ? void 0 : branch.contains(event.target));
+      if (isFocusInBranch) return;
+      emits("focusOutside", event);
+      emits("interactOutside", event);
+      if (!event.defaultPrevented) emits("dismiss");
+    }, layerElement);
+    onKeyStroke("Escape", (event) => {
+      const isHighestLayer = index.value === layers.value.size - 1;
+      if (!isHighestLayer) return;
+      emits("escapeKeyDown", event);
+      if (!event.defaultPrevented) emits("dismiss");
+    });
+    watchEffect((cleanupFn) => {
+      if (!layerElement.value) return;
+      if (props.disableOutsidePointerEvents) {
+        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+          context.originalBodyPointerEvents = ownerDocument.value.body.style.pointerEvents;
+          ownerDocument.value.body.style.pointerEvents = "none";
+        }
+        context.layersWithOutsidePointerEventsDisabled.add(layerElement.value);
+      }
+      layers.value.add(layerElement.value);
+      cleanupFn(() => {
+        if (props.disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1 && !isNullish(context.originalBodyPointerEvents)) ownerDocument.value.body.style.pointerEvents = context.originalBodyPointerEvents;
+      });
+    });
+    watchEffect((cleanupFn) => {
+      cleanupFn(() => {
+        if (!layerElement.value) return;
+        layers.value.delete(layerElement.value);
+        context.layersWithOutsidePointerEventsDisabled.delete(layerElement.value);
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        ref: unref(forwardRef),
+        "as-child": _ctx.asChild,
+        as: _ctx.as,
+        "data-dismissable-layer": "",
+        style: normalizeStyle({ pointerEvents: isBodyPointerEventsDisabled.value ? isPointerEventsEnabled.value ? "auto" : "none" : void 0 }),
+        onFocusCapture: unref(focusOutside).onFocusCapture,
+        onBlurCapture: unref(focusOutside).onBlurCapture,
+        onPointerdownCapture: unref(pointerDownOutside).onPointerDownCapture
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "as-child",
+        "as",
+        "style",
+        "onFocusCapture",
+        "onBlurCapture",
+        "onPointerdownCapture"
+      ]);
+    };
+  }
+});
+var DismissableLayer_default = DismissableLayer_vue_vue_type_script_setup_true_lang_default;
+var Teleport_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "Teleport",
+  props: {
+    to: {
+      type: null,
+      required: false,
+      default: "body"
+    },
+    disabled: {
+      type: Boolean,
+      required: false
+    },
+    defer: {
+      type: Boolean,
+      required: false
+    },
+    forceMount: {
+      type: Boolean,
+      required: false
+    }
+  },
+  setup(__props) {
+    const isMounted = useMounted();
+    return (_ctx, _cache) => {
+      return unref(isMounted) || _ctx.forceMount ? (openBlock(), createBlock(Teleport, {
+        key: 0,
+        to: _ctx.to,
+        disabled: _ctx.disabled,
+        defer: _ctx.defer
+      }, [renderSlot(_ctx.$slots, "default")], 8, [
+        "to",
+        "disabled",
+        "defer"
+      ])) : createCommentVNode("v-if", true);
+    };
+  }
+});
+var Teleport_default = Teleport_vue_vue_type_script_setup_true_lang_default;
+export {
+  DismissableLayer_default as D,
+  Presence_default as P,
+  Teleport_default as T,
+  defu as d,
+  handleAndDispatchCustomEvent as h,
+  isNullish as i,
+  useId as u
+};

package/dist/TooltipProvider.vue_vue_type_script_setup_true_lang-DwIfCQjY.js

@@ -0,0 +1,28 @@
+import { defineComponent, openBlock, createBlock, unref, normalizeProps, guardReactiveProps, withCtx, renderSlot } from "vue";
+import { T as TooltipProvider_default } from "./TooltipTrigger.vue_vue_type_script_setup_true_lang-BRyHTWgw.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TooltipProvider",
+  props: {
+    delayDuration: { default: 0 },
+    skipDelayDuration: {},
+    disableHoverableContent: { type: Boolean },
+    disableClosingTrigger: { type: Boolean },
+    disabled: { type: Boolean },
+    ignoreNonKeyboardFocus: { type: Boolean },
+    content: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TooltipProvider_default), normalizeProps(guardReactiveProps(props)), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};