@thxgg/steward 0.1.5 → 0.1.7

package/.output/server/node_modules/reka-ui/dist/shared/clamp.js

@@ -0,0 +1,66 @@
+//#region src/shared/clamp.ts
+/**
+* The `clamp` function restricts a number within a specified range by returning the value itself if it
+* falls within the range, or the closest boundary value if it exceeds the range.
+* @param {number} value - The `value` parameter represents the number that you want to clamp within
+* the specified range defined by `min` and `max` values.
+* @param {number} min - If the `value` parameter is less than the `min` value, the
+* function will return the `min` value.
+* @param {number} max - If the `value` parameter is greater than the `max` value,
+* the function will return `max`.
+* @returns The `clamp` function returns the value of `value` constrained within the range defined by
+* `min` and `max`.
+*/
+function clamp(value, min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY) {
+	return Math.min(max, Math.max(min, value));
+}
+/**
+* The function `roundToStepPrecision` rounds a number to a specified precision step.
+* @param {number} value - The `value` parameter is the number that you want to round to a specific
+* precision based on the `step` parameter.
+* @param {number} step - The `step` parameter in the `roundToStepPrecision` function represents the
+* interval at which you want to round the `value`. For example, if `step` is 0.5, the `value` will be
+* rounded to the nearest half.
+* @returns the `roundedValue` after rounding it to the precision specified by the `step`.
+*/
+function roundToStepPrecision(value, step) {
+	let roundedValue = value;
+	const stepString = step.toString();
+	const pointIndex = stepString.indexOf(".");
+	const precision = pointIndex >= 0 ? stepString.length - pointIndex : 0;
+	if (precision > 0) {
+		const pow = 10 ** precision;
+		roundedValue = Math.round(roundedValue * pow) / pow;
+	}
+	return roundedValue;
+}
+/**
+* The function `snapValueToStep` snaps a given value to the nearest step within a specified range.
+* @param {number} value - The `value` parameter represents the number that you want to snap to the
+* nearest step value.
+* @param {number | undefined} min - The `min` parameter represents the minimum value that the `value`
+* should be snapped to. If `value` is less than `min`, it will be snapped to `min`. If `min` is not
+* provided (undefined), then the snapping will not consider a minimum value.
+* @param {number | undefined} max - The `max` parameter represents the maximum value that the `value`
+* should be snapped to. It ensures that the snapped value does not exceed this maximum value.
+* @param {number} step - The `step` parameter in the `snapValueToStep` function represents the
+* interval at which the `value` should be snapped to. It determines the granularity of the snapping
+* operation. For example, if `step` is 5, the `value` will be snapped to the nearest multiple of
+* @returns a number that has been snapped to the nearest step value within the specified range of minimum and maximum values.
+*/
+function snapValueToStep(value, min, max, step) {
+	min = Number(min);
+	max = Number(max);
+	const remainder = (value - (Number.isNaN(min) ? 0 : min)) % step;
+	let snappedValue = roundToStepPrecision(Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder, step);
+	if (!Number.isNaN(min)) {
+		if (snappedValue < min) snappedValue = min;
+		else if (!Number.isNaN(max) && snappedValue > max) snappedValue = min + Math.floor(roundToStepPrecision((max - min) / step, step)) * step;
+	} else if (!Number.isNaN(max) && snappedValue > max) snappedValue = Math.floor(roundToStepPrecision(max / step, step)) * step;
+	snappedValue = roundToStepPrecision(snappedValue, step);
+	return snappedValue;
+}
+
+//#endregion
+export { clamp, snapValueToStep };
+//# sourceMappingURL=clamp.js.map

package/.output/server/node_modules/reka-ui/dist/shared/createContext.js

@@ -0,0 +1,35 @@
+import { inject, provide } from "vue";
+
+//#region src/shared/createContext.ts
+/**
+* @param providerComponentName - The name(s) of the component(s) providing the context.
+*
+* There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+*
+* @param contextName The description for injection key symbol.
+*/
+function createContext(providerComponentName, contextName) {
+	const symbolDescription = typeof providerComponentName === "string" && !contextName ? `${providerComponentName}Context` : contextName;
+	const injectionKey = Symbol(symbolDescription);
+	/**
+	* @param fallback The context value to return if the injection fails.
+	*
+	* @throws When context injection failed and no fallback is specified.
+	* This happens when the component injecting the context is not a child of the root component providing the context.
+	*/
+	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];
+}
+
+//#endregion
+export { createContext };
+//# sourceMappingURL=createContext.js.map

package/.output/server/node_modules/reka-ui/dist/shared/getActiveElement.js

@@ -0,0 +1,11 @@
+//#region src/shared/getActiveElement.ts
+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;
+}
+
+//#endregion
+export { getActiveElement };
+//# sourceMappingURL=getActiveElement.js.map

package/.output/server/node_modules/reka-ui/dist/shared/handleAndDispatchCustomEvent.js

@@ -0,0 +1,15 @@
+//#region src/shared/handleAndDispatchCustomEvent.ts
+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);
+}
+
+//#endregion
+export { handleAndDispatchCustomEvent };
+//# sourceMappingURL=handleAndDispatchCustomEvent.js.map

package/.output/server/node_modules/reka-ui/dist/shared/isValueEqualOrExist.js

@@ -0,0 +1,22 @@
+import { isNullish } from "./nullish.js";
+import { isEqual } from "ohash";
+
+//#region src/shared/isValueEqualOrExist.ts
+/**
+* The function `isValueEqualOrExist` checks if a value is equal to or exists in another value or
+* array.
+* @param {T | T[] | undefined} base - It represents the base value that you want to compare with the `current` value.
+* @param {T | T[] | undefined} current - The `current` parameter represents the current value that you want to compare with the `base` value or values.
+* @returns The `isValueEqualOrExist` function returns a boolean value. It checks if the `base` value
+* is equal to the `current` value or if the `current` value exists within the `base` value. The
+* function handles cases where `base` can be a single value, an array of values, or undefined.
+*/
+function isValueEqualOrExist(base, current) {
+	if (isNullish(base)) return false;
+	if (Array.isArray(base)) return base.some((val) => isEqual(val, current));
+	else return isEqual(base, current);
+}
+
+//#endregion
+export { isValueEqualOrExist };
+//# sourceMappingURL=isValueEqualOrExist.js.map

package/.output/server/node_modules/reka-ui/dist/shared/nullish.js

@@ -0,0 +1,8 @@
+//#region src/shared/nullish.ts
+function isNullish(value) {
+	return value === null || value === void 0;
+}
+
+//#endregion
+export { isNullish };
+//# sourceMappingURL=nullish.js.map

package/.output/server/node_modules/reka-ui/dist/shared/renderSlotFragments.js

@@ -0,0 +1,14 @@
+import { Fragment } from "vue";
+
+//#region src/shared/renderSlotFragments.ts
+function renderSlotFragments(children) {
+	if (!children) return [];
+	return children.flatMap((child) => {
+		if (child.type === Fragment) return renderSlotFragments(child.children);
+		return [child];
+	});
+}
+
+//#endregion
+export { renderSlotFragments };
+//# sourceMappingURL=renderSlotFragments.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useArrowNavigation.js

@@ -0,0 +1,64 @@
+//#region src/shared/useArrowNavigation.ts
+const ignoredElement = ["INPUT", "TEXTAREA"];
+/**
+* Allow arrow navigation for every html element with data-reka-collection-item tag
+*
+* @param e               Keyboard event
+* @param currentElement  Event initiator element or any element that wants to handle the navigation
+* @param parentElement   Parent element where contains all the collection items, this will collect every item to be used when nav
+* @param options         further options
+* @returns               the navigated html element or null if none
+*/
+function useArrowNavigation(e, currentElement, parentElement, options = {}) {
+	if (!currentElement || options.enableIgnoredElement && ignoredElement.includes(currentElement.nodeName)) return null;
+	const { arrowKeyOptions = "both", attributeName = "[data-reka-collection-item]", itemsArray = [], loop = true, dir = "ltr", preventScroll = true, focus = false } = options;
+	const [right, left, up, down, home, end] = [
+		e.key === "ArrowRight",
+		e.key === "ArrowLeft",
+		e.key === "ArrowUp",
+		e.key === "ArrowDown",
+		e.key === "Home",
+		e.key === "End"
+	];
+	const goingVertical = up || down;
+	const goingHorizontal = right || left;
+	if (!home && !end && (!goingVertical && !goingHorizontal || arrowKeyOptions === "vertical" && goingHorizontal || arrowKeyOptions === "horizontal" && goingVertical)) return null;
+	const allCollectionItems = parentElement ? Array.from(parentElement.querySelectorAll(attributeName)) : itemsArray;
+	if (!allCollectionItems.length) return null;
+	if (preventScroll) e.preventDefault();
+	let item = null;
+	if (goingHorizontal || goingVertical) {
+		const goForward = goingVertical ? down : dir === "ltr" ? right : left;
+		item = findNextFocusableElement(allCollectionItems, currentElement, {
+			goForward,
+			loop
+		});
+	} else if (home) item = allCollectionItems.at(0) || null;
+	else if (end) item = allCollectionItems.at(-1) || null;
+	if (focus) item?.focus();
+	return item;
+}
+/**
+* Recursive function to find the next focusable element to avoid disabled elements
+*
+* @param elements Elements to navigate
+* @param currentElement Current active element
+* @param options
+* @returns next focusable element
+*/
+function findNextFocusableElement(elements, currentElement, options, iterations = elements.length) {
+	if (--iterations === 0) return null;
+	const index = elements.indexOf(currentElement);
+	const newIndex = options.goForward ? index + 1 : index - 1;
+	if (!options.loop && (newIndex < 0 || newIndex >= elements.length)) return null;
+	const adjustedNewIndex = (newIndex + elements.length) % elements.length;
+	const candidate = elements[adjustedNewIndex];
+	if (!candidate) return null;
+	const isDisabled = candidate.hasAttribute("disabled") && candidate.getAttribute("disabled") !== "false";
+	if (isDisabled) return findNextFocusableElement(elements, candidate, options, iterations);
+	return candidate;
+}
+
+//#endregion
+export { useArrowNavigation };
+//# sourceMappingURL=useArrowNavigation.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useBodyScrollLock.js

@@ -0,0 +1,95 @@
+import { injectConfigProviderContext } from "../ConfigProvider/ConfigProvider.js";
+import { computed, nextTick, ref, watch } from "vue";
+import { createSharedComposable, useEventListener } from "@vueuse/core";
+import { isClient, isIOS, tryOnBeforeUnmount } from "@vueuse/shared";
+import { defu } from "defu";
+
+//#region src/shared/useBodyScrollLock.ts
+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?.();
+		initialOverflow.value = void 0;
+	};
+	watch(locked, (val, oldVal) => {
+		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 = context.scrollBody?.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(() => {
+			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;
+}
+
+//#endregion
+export { useBodyScrollLock };
+//# sourceMappingURL=useBodyScrollLock.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useDateFormatter.js

@@ -0,0 +1,140 @@
+import { hasTime, isZonedDateTime, toDate } from "../date/comparators.js";
+import { ref } from "vue";
+import { DateFormatter, getLocalTimeZone, today } from "@internationalized/date";
+
+//#region src/shared/useDateFormatter.ts
+/**
+* Creates a wrapper around the `DateFormatter`, which is
+* an improved version of the {@link Intl.DateTimeFormat} API,
+* that is used internally by the various date builders to
+* easily format dates in a consistent way.
+*
+* @see [DateFormatter](https://react-spectrum.adobe.com/internationalized/date/DateFormatter.html)
+*/
+function useDateFormatter(initialLocale, opts = {}) {
+	const locale = ref(initialLocale);
+	function getLocale() {
+		return locale.value;
+	}
+	function setLocale(newLocale) {
+		locale.value = newLocale;
+	}
+	function custom(date, options) {
+		return new DateFormatter(locale.value, {
+			...opts,
+			...options
+		}).format(date);
+	}
+	function selectedDate(date, includeTime = true) {
+		if (hasTime(date) && includeTime) return custom(toDate(date), {
+			dateStyle: "long",
+			timeStyle: "long"
+		});
+		else return custom(toDate(date), { dateStyle: "long" });
+	}
+	function fullMonthAndYear(date, options = {}) {
+		return new DateFormatter(locale.value, {
+			...opts,
+			month: "long",
+			year: "numeric",
+			...options
+		}).format(date);
+	}
+	function fullMonth(date, options = {}) {
+		return new DateFormatter(locale.value, {
+			...opts,
+			month: "long",
+			...options
+		}).format(date);
+	}
+	function getMonths() {
+		const defaultDate = today(getLocalTimeZone());
+		const months = [
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10,
+			11,
+			12
+		];
+		return months.map((item) => ({
+			label: fullMonth(toDate(defaultDate.set({ month: item }))),
+			value: item
+		}));
+	}
+	function fullYear(date, options = {}) {
+		return new DateFormatter(locale.value, {
+			...opts,
+			year: "numeric",
+			...options
+		}).format(date);
+	}
+	function toParts(date, options) {
+		if (isZonedDateTime(date)) return new DateFormatter(locale.value, {
+			...opts,
+			...options,
+			timeZone: date.timeZone
+		}).formatToParts(toDate(date));
+		else return new DateFormatter(locale.value, {
+			...opts,
+			...options
+		}).formatToParts(toDate(date));
+	}
+	function dayOfWeek(date, length = "narrow") {
+		return new DateFormatter(locale.value, {
+			...opts,
+			weekday: length
+		}).format(date);
+	}
+	function dayPeriod(date) {
+		const parts = new DateFormatter(locale.value, {
+			...opts,
+			hour: "numeric",
+			minute: "numeric"
+		}).formatToParts(date);
+		const value = parts.find((p) => p.type === "dayPeriod")?.value;
+		if (value === "PM" || value === "pm" || value === "p.m.") return "PM";
+		return "AM";
+	}
+	const defaultPartOptions = {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	};
+	function part(dateObj, type, options = {}) {
+		const opts$1 = {
+			...defaultPartOptions,
+			...options
+		};
+		const parts = toParts(dateObj, opts$1);
+		const part$1 = parts.find((p) => p.type === type);
+		return part$1 ? part$1.value : "";
+	}
+	return {
+		setLocale,
+		getLocale,
+		fullMonth,
+		fullYear,
+		fullMonthAndYear,
+		toParts,
+		custom,
+		part,
+		dayPeriod,
+		selectedDate,
+		dayOfWeek,
+		getMonths
+	};
+}
+
+//#endregion
+export { useDateFormatter };
+//# sourceMappingURL=useDateFormatter.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useDirection.js

@@ -0,0 +1,17 @@
+import { injectConfigProviderContext } from "../ConfigProvider/ConfigProvider.js";
+import { computed, ref } from "vue";
+
+//#region src/shared/useDirection.ts
+/**
+* The `useDirection` function provides a way to access the current direction in your application.
+* @param {Ref<Direction | undefined>} [dir] - An optional ref containing the direction (ltr or rtl).
+* @returns  computed value that combines with the resolved direction.
+*/
+function useDirection(dir) {
+	const context = injectConfigProviderContext({ dir: ref("ltr") });
+	return computed(() => dir?.value || context.dir?.value || "ltr");
+}
+
+//#endregion
+export { useDirection };
+//# sourceMappingURL=useDirection.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useEmitAsProps.js

@@ -0,0 +1,26 @@
+import { camelize, getCurrentInstance, toHandlerKey } from "vue";
+
+//#region src/shared/useEmitAsProps.ts
+/**
+* The `useEmitAsProps` function is a TypeScript utility that converts emitted events into props for a
+* Vue component.
+* @param emit - The `emit` parameter is a function that is used to emit events from a component. It
+* takes two parameters: `name` which is the name of the event to be emitted, and `...args` which are
+* the arguments to be passed along with the event.
+* @returns The function `useEmitAsProps` returns an object that maps event names to functions that
+* call the `emit` function with the corresponding event name and arguments.
+*/
+function useEmitAsProps(emit) {
+	const vm = getCurrentInstance();
+	const events = vm?.type.emits;
+	const result = {};
+	if (!events?.length) console.warn(`No emitted event found. Please check component: ${vm?.type.__name}`);
+	events?.forEach((ev) => {
+		result[toHandlerKey(camelize(ev))] = (...arg) => emit(ev, ...arg);
+	});
+	return result;
+}
+
+//#endregion
+export { useEmitAsProps };
+//# sourceMappingURL=useEmitAsProps.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useFilter.js

@@ -0,0 +1,58 @@
+import { computed, unref } from "vue";
+
+//#region src/shared/useFilter.ts
+/**
+* Provides locale-aware string filtering functions.
+* Uses `Intl.Collator` for comparison to ensure proper Unicode handling.
+*
+* @param options - Optional collator options to customize comparison behavior.
+*   See [Intl.CollatorOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator#options) for details.
+* @returns An object with methods to check if a string starts with, ends with, or contains a substring.
+*
+* @example
+* const { startsWith, endsWith, contains } = useFilter();
+*
+* startsWith('hello', 'he'); // true
+* endsWith('hello', 'lo'); // true
+* contains('hello', 'ell'); // true
+*/
+function useFilter(options) {
+	const computedOptions = computed(() => unref(options));
+	const collator = computed(() => new Intl.Collator("en", {
+		usage: "search",
+		...computedOptions.value
+	}));
+	const startsWith = (string, substring) => {
+		if (substring.length === 0) return true;
+		string = string.normalize("NFC");
+		substring = substring.normalize("NFC");
+		return collator.value.compare(string.slice(0, substring.length), substring) === 0;
+	};
+	const endsWith = (string, substring) => {
+		if (substring.length === 0) return true;
+		string = string.normalize("NFC");
+		substring = substring.normalize("NFC");
+		return collator.value.compare(string.slice(-substring.length), substring) === 0;
+	};
+	const contains = (string, substring) => {
+		if (substring.length === 0) return true;
+		string = string.normalize("NFC");
+		substring = substring.normalize("NFC");
+		let scan = 0;
+		const sliceLen = substring.length;
+		for (; scan + sliceLen <= string.length; scan++) {
+			const slice = string.slice(scan, scan + sliceLen);
+			if (collator.value.compare(substring, slice) === 0) return true;
+		}
+		return false;
+	};
+	return {
+		startsWith,
+		endsWith,
+		contains
+	};
+}
+
+//#endregion
+export { useFilter };
+//# sourceMappingURL=useFilter.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useFocusGuards.js

@@ -0,0 +1,37 @@
+import { watchEffect } from "vue";
+import { isClient } from "@vueuse/shared";
+
+//#region src/shared/useFocusGuards.ts
+/** Number of components which have requested interest to have focus guards */
+let count = 0;
+/**
+* Injects a pair of focus guards at the edges of the whole DOM tree
+* to ensure `focusin` & `focusout` events can be caught consistently.
+*/
+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;
+}
+
+//#endregion
+export { useFocusGuards };
+//# sourceMappingURL=useFocusGuards.js.map

package/.output/server/node_modules/reka-ui/dist/shared/useFormControl.js

@@ -0,0 +1,11 @@
+import { computed, toValue } from "vue";
+import { unrefElement } from "@vueuse/core";
+
+//#region src/shared/useFormControl.ts
+function useFormControl(el) {
+	return computed(() => toValue(el) ? Boolean(unrefElement(el)?.closest("form")) : true);
+}
+
+//#endregion
+export { useFormControl };
+//# sourceMappingURL=useFormControl.js.map