@brumaombra/ui-vintage 0.1.0

package/dist/switch-form-component.d.ts

@@ -0,0 +1,6 @@
+export * from './components/switch-form-component/index'
+export {}
+import ThemeVintage from './components/switch-form-component/index'
+export default ThemeVintage
+export * from './components/switch-form-component/index'
+export {}

package/dist/switch-form-component.js

@@ -0,0 +1,5 @@
+import { _, _ as _2 } from "./SwitchFormComponent.vue_vue_type_script_setup_true_lang-XOBEs3pa.js";
+export {
+  _ as SwitchFormComponent,
+  _2 as default
+};

package/dist/switch.d.ts

@@ -0,0 +1,2 @@
+export * from './components/ui/switch/index'
+export {}

package/dist/switch.js

@@ -0,0 +1,4 @@
+import { _ } from "./Switch.vue_vue_type_script_setup_true_lang-BWKCycMm.js";
+export {
+  _ as Switch
+};

package/dist/tooltip.d.ts

@@ -0,0 +1,2 @@
+export * from './components/ui/tooltip/index'
+export {}

package/dist/tooltip.js

@@ -0,0 +1,8 @@
+import { _, a, b } from "./TooltipTrigger.vue_vue_type_script_setup_true_lang-BRyHTWgw.js";
+import { _ as _2 } from "./TooltipProvider.vue_vue_type_script_setup_true_lang-DwIfCQjY.js";
+export {
+  _ as Tooltip,
+  a as TooltipContent,
+  _2 as TooltipProvider,
+  b as TooltipTrigger
+};

package/dist/useDirection-SIyEYNxv.js

@@ -0,0 +1,12 @@
+import { i as injectConfigProviderContext } from "./ConfigProvider-D2O0Jles.js";
+import { ref, computed } from "vue";
+function useDirection(dir) {
+  const context = injectConfigProviderContext({ dir: ref("ltr") });
+  return computed(() => {
+    var _a;
+    return (dir == null ? void 0 : dir.value) || ((_a = context.dir) == null ? void 0 : _a.value) || "ltr";
+  });
+}
+export {
+  useDirection as u
+};

package/dist/useFocusGuards-tgErlvMF.js

@@ -0,0 +1,29 @@
+import { watchEffect } from "vue";
+import { i as isClient } from "./index-Dfi5ESP2.js";
+let count = 0;
+function useFocusGuards() {
+  watchEffect((cleanupFn) => {
+    if (!isClient) return;
+    const edgeGuards = document.querySelectorAll("[data-reka-focus-guard]");
+    document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard());
+    document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard());
+    count++;
+    cleanupFn(() => {
+      if (count === 1) document.querySelectorAll("[data-reka-focus-guard]").forEach((node) => node.remove());
+      count--;
+    });
+  });
+}
+function createFocusGuard() {
+  const element = document.createElement("span");
+  element.setAttribute("data-reka-focus-guard", "");
+  element.tabIndex = 0;
+  element.style.outline = "none";
+  element.style.opacity = "0";
+  element.style.position = "fixed";
+  element.style.pointerEvents = "none";
+  return element;
+}
+export {
+  useFocusGuards as u
+};

package/dist/useFormControl-7ytzz-r7.js

@@ -0,0 +1,11 @@
+import { computed, toValue } from "vue";
+import { a as unrefElement } from "./index-C1_fxYhb.js";
+function useFormControl(el) {
+  return computed(() => {
+    var _a;
+    return toValue(el) ? Boolean((_a = unrefElement(el)) == null ? void 0 : _a.closest("form")) : true;
+  });
+}
+export {
+  useFormControl as u
+};

package/dist/useForwardExpose-CNVHwdF2.js

@@ -0,0 +1,58 @@
+import { getCurrentInstance, ref, computed, onUpdated, triggerRef } from "vue";
+import { a as unrefElement } from "./index-C1_fxYhb.js";
+function useForwardExpose() {
+  const instance = getCurrentInstance();
+  const currentRef = ref();
+  const currentElement = computed(() => resolveCurrentElement());
+  onUpdated(() => {
+    if (currentElement.value !== resolveCurrentElement()) triggerRef(currentRef);
+  });
+  function resolveCurrentElement() {
+    return currentRef.value && "$el" in currentRef.value && ["#text", "#comment"].includes(currentRef.value.$el.nodeName) ? currentRef.value.$el.nextElementSibling : unrefElement(currentRef);
+  }
+  const localExpose = Object.assign({}, instance.exposed);
+  const ret = {};
+  for (const key in instance.props) Object.defineProperty(ret, key, {
+    enumerable: true,
+    configurable: true,
+    get: () => instance.props[key]
+  });
+  if (Object.keys(localExpose).length > 0) for (const key in localExpose) Object.defineProperty(ret, key, {
+    enumerable: true,
+    configurable: true,
+    get: () => localExpose[key]
+  });
+  Object.defineProperty(ret, "$el", {
+    enumerable: true,
+    configurable: true,
+    get: () => instance.vnode.el
+  });
+  instance.exposed = ret;
+  function forwardRef(ref$1) {
+    currentRef.value = ref$1;
+    if (!ref$1) return;
+    Object.defineProperty(ret, "$el", {
+      enumerable: true,
+      configurable: true,
+      get: () => ref$1 instanceof Element ? ref$1 : ref$1.$el
+    });
+    if (!(ref$1 instanceof Element) && !Object.prototype.hasOwnProperty.call(ref$1, "$el")) {
+      const childExposed = ref$1.$.exposed;
+      const merged = Object.assign({}, ret);
+      for (const key in childExposed) Object.defineProperty(merged, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => childExposed[key]
+      });
+      instance.exposed = merged;
+    }
+  }
+  return {
+    forwardRef,
+    currentRef,
+    currentElement
+  };
+}
+export {
+  useForwardExpose as u
+};

package/dist/useForwardPropsEmits-DmumnZO5.js

@@ -0,0 +1,63 @@
+import { inject, provide, getCurrentInstance, toHandlerKey, camelize, toRef, computed } from "vue";
+function createContext(providerComponentName, contextName) {
+  const symbolDescription = typeof providerComponentName === "string" && !contextName ? `${providerComponentName}Context` : contextName;
+  const injectionKey = Symbol(symbolDescription);
+  const injectContext = (fallback) => {
+    const context = inject(injectionKey, fallback);
+    if (context) return context;
+    if (context === null) return context;
+    throw new Error(`Injection \`${injectionKey.toString()}\` not found. Component must be used within ${Array.isArray(providerComponentName) ? `one of the following components: ${providerComponentName.join(", ")}` : `\`${providerComponentName}\``}`);
+  };
+  const provideContext = (contextValue) => {
+    provide(injectionKey, contextValue);
+    return contextValue;
+  };
+  return [injectContext, provideContext];
+}
+function useEmitAsProps(emit) {
+  const vm = getCurrentInstance();
+  const events = vm == null ? void 0 : vm.type.emits;
+  const result = {};
+  if (!(events == null ? void 0 : events.length)) console.warn(`No emitted event found. Please check component: ${vm == null ? void 0 : vm.type.__name}`);
+  events == null ? void 0 : events.forEach((ev) => {
+    result[toHandlerKey(camelize(ev))] = (...arg) => emit(ev, ...arg);
+  });
+  return result;
+}
+function useForwardProps(props) {
+  const vm = getCurrentInstance();
+  const defaultProps = Object.keys((vm == null ? void 0 : vm.type.props) ?? {}).reduce((prev, curr) => {
+    const defaultValue = (vm == null ? void 0 : vm.type.props[curr]).default;
+    if (defaultValue !== void 0) prev[curr] = defaultValue;
+    return prev;
+  }, {});
+  const refProps = toRef(props);
+  return computed(() => {
+    const preservedProps = {};
+    const assignedProps = (vm == null ? void 0 : vm.vnode.props) ?? {};
+    Object.keys(assignedProps).forEach((key) => {
+      preservedProps[camelize(key)] = assignedProps[key];
+    });
+    return Object.keys({
+      ...defaultProps,
+      ...preservedProps
+    }).reduce((prev, curr) => {
+      if (refProps.value[curr] !== void 0) prev[curr] = refProps.value[curr];
+      return prev;
+    }, {});
+  });
+}
+function useForwardPropsEmits(props, emit) {
+  const parsedProps = useForwardProps(props);
+  const emitsAsProps = emit ? useEmitAsProps(emit) : {};
+  return computed(() => ({
+    ...parsedProps.value,
+    ...emitsAsProps
+  }));
+}
+export {
+  useForwardProps as a,
+  useEmitAsProps as b,
+  createContext as c,
+  useForwardPropsEmits as u
+};

package/dist/useKbd-JjFOu4f7.js

@@ -0,0 +1,41 @@
+function useKbd() {
+  return {
+    ALT: "Alt",
+    ARROW_DOWN: "ArrowDown",
+    ARROW_LEFT: "ArrowLeft",
+    ARROW_RIGHT: "ArrowRight",
+    ARROW_UP: "ArrowUp",
+    BACKSPACE: "Backspace",
+    CAPS_LOCK: "CapsLock",
+    CONTROL: "Control",
+    DELETE: "Delete",
+    END: "End",
+    ENTER: "Enter",
+    ESCAPE: "Escape",
+    F1: "F1",
+    F10: "F10",
+    F11: "F11",
+    F12: "F12",
+    F2: "F2",
+    F3: "F3",
+    F4: "F4",
+    F5: "F5",
+    F6: "F6",
+    F7: "F7",
+    F8: "F8",
+    F9: "F9",
+    HOME: "Home",
+    META: "Meta",
+    PAGE_DOWN: "PageDown",
+    PAGE_UP: "PageUp",
+    SHIFT: "Shift",
+    SPACE: " ",
+    TAB: "Tab",
+    CTRL: "Control",
+    ASTERISK: "*",
+    SPACE_CODE: "Space"
+  };
+}
+export {
+  useKbd as u
+};

package/dist/usePrimitiveElement-CijaRBgF.js

@@ -0,0 +1,16 @@
+import { ref, computed } from "vue";
+import { a as unrefElement } from "./index-C1_fxYhb.js";
+function usePrimitiveElement() {
+  const primitiveElement = ref();
+  const currentElement = computed(() => {
+    var _a, _b;
+    return ["#text", "#comment"].includes((_a = primitiveElement.value) == null ? void 0 : _a.$el.nodeName) ? (_b = primitiveElement.value) == null ? void 0 : _b.$el.nextElementSibling : unrefElement(primitiveElement);
+  });
+  return {
+    primitiveElement,
+    currentElement
+  };
+}
+export {
+  usePrimitiveElement as u
+};

package/dist/useSize-DO9Z3wC4.js

@@ -0,0 +1,51 @@
+import { ref, computed, onMounted } from "vue";
+import { a as unrefElement } from "./index-C1_fxYhb.js";
+function useSize(element) {
+  const size = ref();
+  const width = computed(() => {
+    var _a;
+    return ((_a = size.value) == null ? void 0 : _a.width) ?? 0;
+  });
+  const height = computed(() => {
+    var _a;
+    return ((_a = size.value) == null ? void 0 : _a.height) ?? 0;
+  });
+  onMounted(() => {
+    const el = unrefElement(element);
+    if (el) {
+      size.value = {
+        width: el.offsetWidth,
+        height: el.offsetHeight
+      };
+      const resizeObserver = new ResizeObserver((entries) => {
+        if (!Array.isArray(entries)) return;
+        if (!entries.length) return;
+        const entry = entries[0];
+        let width$1;
+        let height$1;
+        if ("borderBoxSize" in entry) {
+          const borderSizeEntry = entry.borderBoxSize;
+          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+          width$1 = borderSize.inlineSize;
+          height$1 = borderSize.blockSize;
+        } else {
+          width$1 = el.offsetWidth;
+          height$1 = el.offsetHeight;
+        }
+        size.value = {
+          width: width$1,
+          height: height$1
+        };
+      });
+      resizeObserver.observe(el, { box: "border-box" });
+      return () => resizeObserver.unobserve(el);
+    } else size.value = void 0;
+  });
+  return {
+    width,
+    height
+  };
+}
+export {
+  useSize as u
+};

package/dist/useTypeahead-Dqe1QXq1.js

@@ -0,0 +1,159 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+import { g as getActiveElement } from "./FocusScope-C3mcVwsf.js";
+import { g as refAutoReset } from "./index-Dfi5ESP2.js";
+function serialize(o) {
+  return typeof o == "string" ? `'${o}'` : new c().serialize(o);
+}
+const c = /* @__PURE__ */ function() {
+  var _t;
+  class o {
+    constructor() {
+      __privateAdd(this, _t, /* @__PURE__ */ new Map());
+    }
+    compare(t, r) {
+      const e = typeof t, n = typeof r;
+      return e === "string" && n === "string" ? t.localeCompare(r) : e === "number" && n === "number" ? t - r : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r, true));
+    }
+    serialize(t, r) {
+      if (t === null) return "null";
+      switch (typeof t) {
+        case "string":
+          return r ? t : `'${t}'`;
+        case "bigint":
+          return `${t}n`;
+        case "object":
+          return this.$object(t);
+        case "function":
+          return this.$function(t);
+      }
+      return String(t);
+    }
+    serializeObject(t) {
+      const r = Object.prototype.toString.call(t);
+      if (r !== "[object Object]") return this.serializeBuiltInType(r.length < 10 ? `unknown:${r}` : r.slice(8, -1), t);
+      const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
+      if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
+      if (typeof t.toJSON == "function") {
+        const i = t.toJSON();
+        return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
+      }
+      return this.serializeObjectEntries(n, Object.entries(t));
+    }
+    serializeBuiltInType(t, r) {
+      const e = this["$" + t];
+      if (e) return e.call(this, r);
+      if (typeof (r == null ? void 0 : r.entries) == "function") return this.serializeObjectEntries(t, r.entries());
+      throw new Error(`Cannot serialize ${t}`);
+    }
+    serializeObjectEntries(t, r) {
+      const e = Array.from(r).sort((i, a) => this.compare(i[0], a[0]));
+      let n = `${t}{`;
+      for (let i = 0; i < e.length; i++) {
+        const [a, l] = e[i];
+        n += `${this.serialize(a, true)}:${this.serialize(l)}`, i < e.length - 1 && (n += ",");
+      }
+      return n + "}";
+    }
+    $object(t) {
+      let r = __privateGet(this, _t).get(t);
+      return r === void 0 && (__privateGet(this, _t).set(t, `#${__privateGet(this, _t).size}`), r = this.serializeObject(t), __privateGet(this, _t).set(t, r)), r;
+    }
+    $function(t) {
+      const r = Function.prototype.toString.call(t);
+      return r.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r.replace(/\s*\n\s*/g, "")}`;
+    }
+    $Array(t) {
+      let r = "[";
+      for (let e = 0; e < t.length; e++) r += this.serialize(t[e]), e < t.length - 1 && (r += ",");
+      return r + "]";
+    }
+    $Date(t) {
+      try {
+        return `Date(${t.toISOString()})`;
+      } catch {
+        return "Date(null)";
+      }
+    }
+    $ArrayBuffer(t) {
+      return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
+    }
+    $Set(t) {
+      return `Set${this.$Array(Array.from(t).sort((r, e) => this.compare(r, e)))}`;
+    }
+    $Map(t) {
+      return this.serializeObjectEntries("Map", t.entries());
+    }
+  }
+  _t = new WeakMap();
+  for (const s of ["Error", "RegExp", "URL"]) o.prototype["$" + s] = function(t) {
+    return `${s}(${t})`;
+  };
+  for (const s of ["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array"]) o.prototype["$" + s] = function(t) {
+    return `${s}[${t.join(",")}]`;
+  };
+  for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
+    return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
+  };
+  return o;
+}();
+function isEqual(object1, object2) {
+  if (object1 === object2) {
+    return true;
+  }
+  if (serialize(object1) === serialize(object2)) {
+    return true;
+  }
+  return false;
+}
+function useTypeahead(callback) {
+  const search = refAutoReset("", 1e3);
+  const handleTypeaheadSearch = (key, items) => {
+    search.value = search.value + key;
+    {
+      const currentItem = getActiveElement();
+      const itemsWithTextValue = items.map((item) => {
+        var _a, _b;
+        return {
+          ...item,
+          textValue: ((_a = item.value) == null ? void 0 : _a.textValue) ?? ((_b = item.ref.textContent) == null ? void 0 : _b.trim()) ?? ""
+        };
+      });
+      const currentMatch = itemsWithTextValue.find((item) => item.ref === currentItem);
+      const values = itemsWithTextValue.map((item) => item.textValue);
+      const nextMatch = getNextMatch(values, search.value, currentMatch == null ? void 0 : currentMatch.textValue);
+      const newItem = itemsWithTextValue.find((item) => item.textValue === nextMatch);
+      if (newItem) newItem.ref.focus();
+      return newItem == null ? void 0 : newItem.ref;
+    }
+  };
+  const resetTypeahead = () => {
+    search.value = "";
+  };
+  return {
+    search,
+    handleTypeaheadSearch,
+    resetTypeahead
+  };
+}
+function wrapArray(array, startIndex) {
+  return array.map((_, index) => array[(startIndex + index) % array.length]);
+}
+function getNextMatch(values, search, currentMatch) {
+  const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
+  const normalizedSearch = isRepeated ? search[0] : search;
+  const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+  let wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));
+  const excludeCurrentMatch = normalizedSearch.length === 1;
+  if (excludeCurrentMatch) wrappedValues = wrappedValues.filter((v) => v !== currentMatch);
+  const nextMatch = wrappedValues.find((value) => value.toLowerCase().startsWith(normalizedSearch.toLowerCase()));
+  return nextMatch !== currentMatch ? nextMatch : void 0;
+}
+export {
+  isEqual as i,
+  useTypeahead as u
+};