@proyecto-viviana/solidaria 0.3.0 → 0.4.1

package/dist/_chunk/locale.jsx

@@ -0,0 +1,167 @@
+import { createContext, createEffect, createMemo, createSignal, onCleanup, useContext } from "solid-js";
+//#region src/i18n/utils.ts
+/**
+* i18n utilities for solidaria
+*
+* RTL detection and locale utilities.
+*
+* Port of @react-aria/i18n utils.
+*/
+const RTL_SCRIPTS = new Set([
+	"Arab",
+	"Syrc",
+	"Samr",
+	"Mand",
+	"Thaa",
+	"Mend",
+	"Nkoo",
+	"Adlm",
+	"Rohg",
+	"Hebr"
+]);
+const RTL_LANGS = new Set([
+	"ae",
+	"ar",
+	"arc",
+	"bcc",
+	"bqi",
+	"ckb",
+	"dv",
+	"fa",
+	"glk",
+	"he",
+	"ku",
+	"mzn",
+	"nqo",
+	"pnb",
+	"ps",
+	"sd",
+	"ug",
+	"ur",
+	"yi"
+]);
+/**
+* Determines if a locale is read right to left.
+* Uses Intl.Locale API when available for accurate detection.
+*/
+function isRTL(localeString) {
+	if (typeof Intl !== "undefined" && Intl.Locale) try {
+		const locale = new Intl.Locale(localeString).maximize();
+		const localeAny = locale;
+		const textInfo = typeof localeAny.getTextInfo === "function" ? localeAny.getTextInfo() : localeAny.textInfo;
+		if (textInfo) return textInfo.direction === "rtl";
+		if (locale.script) return RTL_SCRIPTS.has(locale.script);
+	} catch {}
+	const lang = localeString.split("-")[0];
+	return RTL_LANGS.has(lang);
+}
+/**
+* Creates a cache key for formatter options.
+*/
+function createCacheKey(locale, options) {
+	if (!options) return locale;
+	return locale + Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join();
+}
+//#endregion
+//#region src/i18n/locale.tsx
+/**
+* Locale context and provider for solidaria
+*
+* Provides locale and text direction to the component tree.
+*
+* Port of @react-aria/i18n context and useDefaultLocale.
+*/
+const localeSymbol = Symbol.for("solidaria.i18n.locale");
+let currentLocale = null;
+const listeners = /* @__PURE__ */ new Set();
+/**
+* Gets the default locale from the browser/system.
+*/
+function getDefaultLocale() {
+	let locale = typeof window !== "undefined" && window[localeSymbol] || typeof navigator !== "undefined" && (navigator.language || navigator.userLanguage) || "en-US";
+	try {
+		Intl.DateTimeFormat.supportedLocalesOf([locale]);
+	} catch {
+		locale = "en-US";
+	}
+	return {
+		locale,
+		direction: isRTL(locale) ? "rtl" : "ltr"
+	};
+}
+function updateLocale() {
+	currentLocale = getDefaultLocale();
+	for (const listener of listeners) listener(currentLocale);
+}
+const I18nContext = createContext(null);
+/**
+* Returns the current browser/system locale, and updates when it changes.
+*
+* @example
+* ```tsx
+* const locale = createDefaultLocale();
+* console.log(locale().locale); // 'en-US'
+* console.log(locale().direction); // 'ltr'
+* ```
+*/
+function createDefaultLocale() {
+	if (!currentLocale) currentLocale = getDefaultLocale();
+	const [locale, setLocale] = createSignal(currentLocale);
+	createEffect(() => {
+		if (typeof window === "undefined") return;
+		if (listeners.size === 0) window.addEventListener("languagechange", updateLocale);
+		listeners.add(setLocale);
+		onCleanup(() => {
+			listeners.delete(setLocale);
+			if (listeners.size === 0) window.removeEventListener("languagechange", updateLocale);
+		});
+	});
+	return locale;
+}
+/**
+* Returns the current locale and layout direction from context or browser default.
+*
+* @example
+* ```tsx
+* function MyComponent() {
+*   const locale = useLocale();
+*   return <div dir={locale().direction}>{locale().locale}</div>;
+* }
+* ```
+*/
+function useLocale() {
+	const context = useContext(I18nContext);
+	const defaultLocale = createDefaultLocale();
+	return context || defaultLocale;
+}
+/**
+* Provides the locale for the application to all child components.
+*
+* @example
+* ```tsx
+* // Use browser default locale
+* <I18nProvider>
+*   <App />
+* </I18nProvider>
+*
+* // Override with specific locale
+* <I18nProvider locale="ar-SA">
+*   <App /> // Will have RTL direction
+* </I18nProvider>
+* ```
+*/
+function I18nProvider(props) {
+	const defaultLocale = createDefaultLocale();
+	const locale = createMemo(() => {
+		if (props.locale) return {
+			locale: props.locale,
+			direction: isRTL(props.locale) ? "rtl" : "ltr"
+		};
+		return defaultLocale();
+	});
+	return <I18nContext.Provider value={locale}>{props.children}</I18nContext.Provider>;
+}
+//#endregion
+export { createCacheKey as a, useLocale as i, createDefaultLocale as n, isRTL as o, getDefaultLocale as r, I18nProvider as t };
+
+//# sourceMappingURL=locale.jsx.map

package/dist/_chunk/locale.jsx.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.jsx","names":[],"sources":["../../src/i18n/utils.ts","../../src/i18n/locale.tsx"],"sourcesContent":["/**\n * i18n utilities for solidaria\n *\n * RTL detection and locale utilities.\n *\n * Port of @react-aria/i18n utils.\n */\n\n// https://en.wikipedia.org/wiki/Right-to-left\nconst RTL_SCRIPTS = new Set([\n  \"Arab\",\n  \"Syrc\",\n  \"Samr\",\n  \"Mand\",\n  \"Thaa\",\n  \"Mend\",\n  \"Nkoo\",\n  \"Adlm\",\n  \"Rohg\",\n  \"Hebr\",\n]);\n\nconst RTL_LANGS = new Set([\n  \"ae\",\n  \"ar\",\n  \"arc\",\n  \"bcc\",\n  \"bqi\",\n  \"ckb\",\n  \"dv\",\n  \"fa\",\n  \"glk\",\n  \"he\",\n  \"ku\",\n  \"mzn\",\n  \"nqo\",\n  \"pnb\",\n  \"ps\",\n  \"sd\",\n  \"ug\",\n  \"ur\",\n  \"yi\",\n]);\n\n/**\n * Determines if a locale is read right to left.\n * Uses Intl.Locale API when available for accurate detection.\n */\nexport function isRTL(localeString: string): boolean {\n  // If the Intl.Locale API is available, use it to get the locale's text direction.\n  if (typeof Intl !== \"undefined\" && Intl.Locale) {\n    try {\n      const locale = new Intl.Locale(localeString).maximize();\n\n      // Use the text info object to get the direction if possible.\n      // getTextInfo() was implemented as a property by some browsers before it was standardized as a function.\n      const localeAny = locale as unknown as {\n        getTextInfo?: () => { direction: string };\n        textInfo?: { direction: string };\n      };\n      const textInfo =\n        typeof localeAny.getTextInfo === \"function\" ? localeAny.getTextInfo() : localeAny.textInfo;\n\n      if (textInfo) {\n        return textInfo.direction === \"rtl\";\n      }\n\n      // Fallback: guess using the script.\n      if (locale.script) {\n        return RTL_SCRIPTS.has(locale.script);\n      }\n    } catch {\n      // Fall through to language-based detection\n    }\n  }\n\n  // If not, just guess by the language (first part of the locale)\n  const lang = localeString.split(\"-\")[0];\n  return RTL_LANGS.has(lang);\n}\n\n/**\n * Creates a cache key for formatter options.\n */\nexport function createCacheKey(locale: string, options?: Record<string, unknown>): string {\n  if (!options) {\n    return locale;\n  }\n  return (\n    locale +\n    Object.entries(options)\n      .sort((a, b) => (a[0] < b[0] ? -1 : 1))\n      .join()\n  );\n}\n","/**\n * Locale context and provider for solidaria\n *\n * Provides locale and text direction to the component tree.\n *\n * Port of @react-aria/i18n context and useDefaultLocale.\n */\n\nimport {\n  type Accessor,\n  type JSX,\n  type ParentProps,\n  createContext,\n  createEffect,\n  createMemo,\n  createSignal,\n  onCleanup,\n  useContext,\n} from \"solid-js\";\nimport { isRTL } from \"./utils\";\n\n/** Text direction: left-to-right or right-to-left. */\nexport type Direction = \"ltr\" | \"rtl\";\n\n/** Locale information including language code and text direction. */\nexport interface Locale {\n  /** The BCP47 language code for the locale (e.g., 'en-US', 'ar-SA'). */\n  locale: string;\n  /** The writing direction for the locale. */\n  direction: Direction;\n}\n\nexport interface I18nProviderProps extends ParentProps {\n  /** The locale to apply to the children. If not provided, uses browser default. */\n  locale?: string;\n}\n\n// Symbol for server-provided locale\nconst localeSymbol = Symbol.for(\"solidaria.i18n.locale\");\n\nlet currentLocale: Locale | null = null;\nconst listeners = new Set<(locale: Locale) => void>();\n\n/**\n * Gets the default locale from the browser/system.\n */\nexport function getDefaultLocale(): Locale {\n  let locale =\n    (typeof window !== \"undefined\" &&\n      (window as unknown as Record<symbol, string>)[localeSymbol]) ||\n    (typeof navigator !== \"undefined\" &&\n      (navigator.language || (navigator as unknown as { userLanguage?: string }).userLanguage)) ||\n    \"en-US\";\n\n  // Validate the locale is supported\n  try {\n    Intl.DateTimeFormat.supportedLocalesOf([locale]);\n  } catch {\n    locale = \"en-US\";\n  }\n\n  return {\n    locale,\n    direction: isRTL(locale) ? \"rtl\" : \"ltr\",\n  };\n}\n\nfunction updateLocale(): void {\n  currentLocale = getDefaultLocale();\n  for (const listener of listeners) {\n    listener(currentLocale);\n  }\n}\n\nconst I18nContext = createContext<Accessor<Locale> | null>(null);\n\n/**\n * Returns the current browser/system locale, and updates when it changes.\n *\n * @example\n * ```tsx\n * const locale = createDefaultLocale();\n * console.log(locale().locale); // 'en-US'\n * console.log(locale().direction); // 'ltr'\n * ```\n */\nexport function createDefaultLocale(): Accessor<Locale> {\n  if (!currentLocale) {\n    currentLocale = getDefaultLocale();\n  }\n\n  const [locale, setLocale] = createSignal<Locale>(currentLocale);\n\n  createEffect(() => {\n    if (typeof window === \"undefined\") {\n      return;\n    }\n\n    if (listeners.size === 0) {\n      window.addEventListener(\"languagechange\", updateLocale);\n    }\n\n    listeners.add(setLocale);\n\n    onCleanup(() => {\n      listeners.delete(setLocale);\n      if (listeners.size === 0) {\n        window.removeEventListener(\"languagechange\", updateLocale);\n      }\n    });\n  });\n\n  return locale;\n}\n\n/**\n * Returns the current locale and layout direction from context or browser default.\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const locale = useLocale();\n *   return <div dir={locale().direction}>{locale().locale}</div>;\n * }\n * ```\n */\nexport function useLocale(): Accessor<Locale> {\n  const context = useContext(I18nContext);\n  const defaultLocale = createDefaultLocale();\n  return context || defaultLocale;\n}\n\n/**\n * Provides the locale for the application to all child components.\n *\n * @example\n * ```tsx\n * // Use browser default locale\n * <I18nProvider>\n *   <App />\n * </I18nProvider>\n *\n * // Override with specific locale\n * <I18nProvider locale=\"ar-SA\">\n *   <App /> // Will have RTL direction\n * </I18nProvider>\n * ```\n */\nexport function I18nProvider(props: I18nProviderProps): JSX.Element {\n  const defaultLocale = createDefaultLocale();\n\n  const locale = createMemo<Locale>(() => {\n    if (props.locale) {\n      return {\n        locale: props.locale,\n        direction: isRTL(props.locale) ? \"rtl\" : \"ltr\",\n      };\n    }\n    return defaultLocale();\n  });\n\n  return <I18nContext.Provider value={locale}>{props.children}</I18nContext.Provider>;\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,cAAc,IAAI,IAAI;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,MAAM,YAAY,IAAI,IAAI;CACxB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;AAMD,SAAgB,MAAM,cAA+B;CAEnD,IAAI,OAAO,SAAS,eAAe,KAAK,QACtC,IAAI;EACF,MAAM,SAAS,IAAI,KAAK,OAAO,YAAY,CAAC,CAAC,SAAS;EAItD,MAAM,YAAY;EAIlB,MAAM,WACJ,OAAO,UAAU,gBAAgB,aAAa,UAAU,YAAY,IAAI,UAAU;EAEpF,IAAI,UACF,OAAO,SAAS,cAAc;EAIhC,IAAI,OAAO,QACT,OAAO,YAAY,IAAI,OAAO,MAAM;CAExC,QAAQ,CAER;CAIF,MAAM,OAAO,aAAa,MAAM,GAAG,CAAC,CAAC;CACrC,OAAO,UAAU,IAAI,IAAI;AAC3B;;;;AAKA,SAAgB,eAAe,QAAgB,SAA2C;CACxF,IAAI,CAAC,SACH,OAAO;CAET,OACE,SACA,OAAO,QAAQ,OAAO,CAAC,CACpB,MAAM,GAAG,MAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAE,CAAC,CACtC,KAAK;AAEZ;;;;;;;;;;ACxDA,MAAM,eAAe,OAAO,IAAI,uBAAuB;AAEvD,IAAI,gBAA+B;AACnC,MAAM,4BAAY,IAAI,IAA8B;;;;AAKpD,SAAgB,mBAA2B;CACzC,IAAI,SACD,OAAO,WAAW,eAChB,OAA6C,iBAC/C,OAAO,cAAc,gBACnB,UAAU,YAAa,UAAmD,iBAC7E;CAGF,IAAI;EACF,KAAK,eAAe,mBAAmB,CAAC,MAAM,CAAC;CACjD,QAAQ;EACN,SAAS;CACX;CAEA,OAAO;EACL;EACA,WAAW,MAAM,MAAM,IAAI,QAAQ;CACrC;AACF;AAEA,SAAS,eAAqB;CAC5B,gBAAgB,iBAAiB;CACjC,KAAK,MAAM,YAAY,WACrB,SAAS,aAAa;AAE1B;AAEA,MAAM,cAAc,cAAuC,IAAI;;;;;;;;;;;AAY/D,SAAgB,sBAAwC;CACtD,IAAI,CAAC,eACH,gBAAgB,iBAAiB;CAGnC,MAAM,CAAC,QAAQ,aAAa,aAAqB,aAAa;CAE9D,mBAAmB;EACjB,IAAI,OAAO,WAAW,aACpB;EAGF,IAAI,UAAU,SAAS,GACrB,OAAO,iBAAiB,kBAAkB,YAAY;EAGxD,UAAU,IAAI,SAAS;EAEvB,gBAAgB;GACd,UAAU,OAAO,SAAS;GAC1B,IAAI,UAAU,SAAS,GACrB,OAAO,oBAAoB,kBAAkB,YAAY;EAE7D,CAAC;CACH,CAAC;CAED,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,YAA8B;CAC5C,MAAM,UAAU,WAAW,WAAW;CACtC,MAAM,gBAAgB,oBAAoB;CAC1C,OAAO,WAAW;AACpB;;;;;;;;;;;;;;;;;AAkBA,SAAgB,aAAa,OAAuC;CAClE,MAAM,gBAAgB,oBAAoB;CAE1C,MAAM,SAAS,iBAAyB;EACtC,IAAI,MAAM,QACR,OAAO;GACL,QAAQ,MAAM;GACd,WAAW,MAAM,MAAM,MAAM,IAAI,QAAQ;EAC3C;EAEF,OAAO,cAAc;CACvB,CAAC;CAED,OAAO,CAAC,YAAY,SAAS,OAAO,SAAS,MAAM,SAAS,EAAE,YAAY;AAC5E"}

package/dist/_chunk/menu.js

@@ -0,0 +1,519 @@
+import { t as createPress } from "./createPress.js";
+import { i as mergeProps$1, t as isDevEnv } from "./env.js";
+import { t as filterDOMProps } from "./filterDOMProps.js";
+import { t as access } from "./reactivity.js";
+import { p as isVirtualClick } from "./utils.js";
+import { a as getEventTarget } from "./focus.js";
+import { t as createFocusWithin } from "./createFocusWithin.js";
+import { t as createFocusRing } from "./createFocusRing.js";
+import { t as createHover } from "./createHover.js";
+import { createId, createSlotId } from "../ssr/index.js";
+import { t as createLabel } from "./createLabel.js";
+import { t as createTypeSelect } from "./createTypeSelect.js";
+import { n as createSelectableItem, r as selectItem } from "./createSelectableItem.js";
+import { createEffect, onCleanup } from "solid-js";
+//#region src/menu/createMenu.ts
+/**
+* Provides the behavior and accessibility implementation for a menu component.
+* A menu displays a list of actions or options that a user can choose.
+* Based on @react-aria/menu useMenu.
+*/
+/**
+* Default number of items to skip for page up/down when DOM measurement is not available.
+*/
+const DEFAULT_PAGE_SIZE = 10;
+/**
+* Find the next non-disabled key in a collection.
+*/
+function findNextNonDisabledKey(collection, currentKey, direction, isDisabled, wrap) {
+	const getNextKey = direction === "next" ? (key) => collection.getKeyAfter(key) : (key) => collection.getKeyBefore(key);
+	const getFirstKey = direction === "next" ? () => collection.getFirstKey() : () => collection.getLastKey();
+	let nextKey = currentKey != null ? getNextKey(currentKey) : getFirstKey();
+	while (nextKey != null && isDisabled(nextKey)) nextKey = getNextKey(nextKey);
+	if (nextKey == null && wrap) {
+		nextKey = getFirstKey();
+		while (nextKey != null && isDisabled(nextKey)) nextKey = getNextKey(nextKey);
+	}
+	return nextKey;
+}
+const menuData = /* @__PURE__ */ new WeakMap();
+function getMenuData(state) {
+	return menuData.get(state);
+}
+/**
+* Provides the behavior and accessibility implementation for a menu component.
+* A menu displays a list of actions or options that a user can choose.
+*/
+function createMenu(props, state, ref) {
+	const getProps = () => access(props);
+	const id = createId(getProps().id);
+	if (isDevEnv()) {
+		const p = getProps();
+		if (!p.label && !p["aria-label"] && !p["aria-labelledby"]) console.warn("[solidaria] A Menu requires an aria-label or aria-labelledby attribute for accessibility.");
+	}
+	const domProps = () => filterDOMProps(getProps(), { labelable: true });
+	const updateSharedData = () => {
+		const p = getProps();
+		menuData.set(state, {
+			id,
+			onAction: p.onAction,
+			onClose: p.onClose,
+			isDisabled: p.isDisabled,
+			shouldCloseOnSelect: p.shouldCloseOnSelect
+		});
+	};
+	updateSharedData();
+	createEffect(() => {
+		updateSharedData();
+		onCleanup(() => {
+			menuData.delete(state);
+		});
+	});
+	const { focusWithinProps } = createFocusWithin({
+		onFocusWithin: (e) => getProps().onFocus?.(e),
+		onBlurWithin: (e) => getProps().onBlur?.(e),
+		onFocusWithinChange: (isFocused) => {
+			getProps().onFocusChange?.(isFocused);
+			state.setFocused(isFocused);
+		}
+	});
+	const { labelProps, fieldProps } = createLabel({
+		get id() {
+			return id;
+		},
+		get label() {
+			return getProps().label;
+		},
+		get "aria-label"() {
+			return getProps()["aria-label"];
+		},
+		get "aria-labelledby"() {
+			return getProps()["aria-labelledby"];
+		},
+		labelElementType: "span"
+	});
+	const { typeSelectProps } = createTypeSelect({
+		collection: () => state.collection(),
+		focusedKey: () => state.focusedKey(),
+		onFocusedKeyChange: (key) => state.setFocusedKey(key),
+		isKeyDisabled: (key) => state.isDisabled(key),
+		get isDisabled() {
+			return getProps().disallowTypeAhead ?? false;
+		}
+	});
+	const onKeyDown = (e) => {
+		if (getProps().isDisabled) return;
+		const collection = state.collection();
+		const p = getProps();
+		const wrap = p.shouldFocusWrap ?? false;
+		const isDisabled = (key) => state.isDisabled(key) && state.disabledBehavior() === "all";
+		switch (e.key) {
+			case "ArrowDown": {
+				const nextKey = findNextNonDisabledKey(collection, state.focusedKey(), "next", isDisabled, wrap);
+				if (nextKey != null) {
+					e.preventDefault();
+					state.setFocusedKey(nextKey);
+				}
+				break;
+			}
+			case "ArrowUp": {
+				const prevKey = findNextNonDisabledKey(collection, state.focusedKey(), "prev", isDisabled, wrap);
+				if (prevKey != null) {
+					e.preventDefault();
+					state.setFocusedKey(prevKey);
+				}
+				break;
+			}
+			case "Home": {
+				if (state.focusedKey() == null && e.shiftKey) break;
+				e.preventDefault();
+				let firstKey = collection.getFirstKey();
+				while (firstKey != null && isDisabled(firstKey)) firstKey = collection.getKeyAfter(firstKey);
+				if (firstKey != null) state.setFocusedKey(firstKey);
+				break;
+			}
+			case "End": {
+				if (state.focusedKey() == null && e.shiftKey) break;
+				e.preventDefault();
+				let lastKey = collection.getLastKey();
+				while (lastKey != null && isDisabled(lastKey)) lastKey = collection.getKeyBefore(lastKey);
+				if (lastKey != null) state.setFocusedKey(lastKey);
+				break;
+			}
+			case " ":
+			case "Enter": {
+				if (e.target !== e.currentTarget) break;
+				e.preventDefault();
+				const focusedKey = state.focusedKey();
+				if (focusedKey != null && !isDisabled(focusedKey)) {
+					selectItem(state, focusedKey, {
+						pointerType: "keyboard",
+						shiftKey: e.shiftKey,
+						ctrlKey: e.ctrlKey,
+						metaKey: e.metaKey,
+						altKey: e.altKey
+					}, collection);
+					p.onAction?.(focusedKey, collection.getItem(focusedKey)?.value);
+					const isLink = !!collection.getItem(focusedKey)?.props?.href;
+					if (p.shouldCloseOnSelect ?? (e.key === "Enter" || state.selectionMode() === "none" || isLink)) p.onClose?.();
+				}
+				break;
+			}
+			case "Escape":
+				e.preventDefault();
+				p.onClose?.();
+				break;
+			case "PageDown": {
+				const currentKey = state.focusedKey();
+				if (currentKey == null) break;
+				e.preventDefault();
+				const el = ref?.();
+				if (el) {
+					const visibleHeight = el.clientHeight;
+					let traveled = 0;
+					let targetKey = currentKey;
+					while (targetKey != null && traveled < visibleHeight) {
+						const nextKey = collection.getKeyAfter(targetKey);
+						if (nextKey == null) break;
+						const itemElement = el.querySelector(`[data-key="${targetKey}"]`);
+						traveled += itemElement?.clientHeight ?? 32;
+						if (!isDisabled(nextKey)) targetKey = nextKey;
+						else {
+							const afterDisabled = findNextNonDisabledKey(collection, nextKey, "next", isDisabled, false);
+							if (afterDisabled != null) targetKey = afterDisabled;
+							else break;
+						}
+					}
+					if (targetKey != null && targetKey !== currentKey) state.setFocusedKey(targetKey);
+				} else {
+					let count = DEFAULT_PAGE_SIZE;
+					let targetKey = currentKey;
+					while (count > 0 && targetKey != null) {
+						const nextKey = findNextNonDisabledKey(collection, targetKey, "next", isDisabled, false);
+						if (nextKey == null) break;
+						targetKey = nextKey;
+						count--;
+					}
+					if (targetKey != null) state.setFocusedKey(targetKey);
+				}
+				break;
+			}
+			case "PageUp": {
+				const currentKey = state.focusedKey();
+				if (currentKey == null) break;
+				e.preventDefault();
+				const el = ref?.();
+				if (el) {
+					const visibleHeight = el.clientHeight;
+					let traveled = 0;
+					let targetKey = currentKey;
+					while (targetKey != null && traveled < visibleHeight) {
+						const prevKey = collection.getKeyBefore(targetKey);
+						if (prevKey == null) break;
+						const itemElement = el.querySelector(`[data-key="${targetKey}"]`);
+						traveled += itemElement?.clientHeight ?? 32;
+						if (!isDisabled(prevKey)) targetKey = prevKey;
+						else {
+							const beforeDisabled = findNextNonDisabledKey(collection, prevKey, "prev", isDisabled, false);
+							if (beforeDisabled != null) targetKey = beforeDisabled;
+							else break;
+						}
+					}
+					if (targetKey != null && targetKey !== currentKey) state.setFocusedKey(targetKey);
+				} else {
+					let count = DEFAULT_PAGE_SIZE;
+					let targetKey = currentKey;
+					while (count > 0 && targetKey != null) {
+						const prevKey = findNextNonDisabledKey(collection, targetKey, "prev", isDisabled, false);
+						if (prevKey == null) break;
+						targetKey = prevKey;
+						count--;
+					}
+					if (targetKey != null) state.setFocusedKey(targetKey);
+				}
+				break;
+			}
+		}
+	};
+	return {
+		get labelProps() {
+			return labelProps;
+		},
+		get menuProps() {
+			const p = getProps();
+			const baseProps = mergeProps$1(domProps(), focusWithinProps, fieldProps, {
+				role: "menu",
+				get tabIndex() {
+					return getProps().isDisabled ? void 0 : state.focusedKey() == null ? 0 : -1;
+				},
+				"aria-disabled": p.isDisabled || void 0,
+				onKeyDown
+			});
+			if (!p.disallowTypeAhead) return mergeProps$1(baseProps, typeSelectProps);
+			return baseProps;
+		}
+	};
+}
+//#endregion
+//#region src/menu/createMenuItem.ts
+/**
+* Provides the behavior and accessibility implementation for a menu item.
+*/
+function createMenuItem(props, state, ref) {
+	const getProps = () => access(props);
+	const getData = () => getMenuData(state);
+	const isDisabled = () => {
+		return Boolean(getData()?.isDisabled || getProps().isDisabled || state.isDisabled(getProps().key));
+	};
+	const selectionMode = () => {
+		return state.selectionMode();
+	};
+	const isLink = () => !!getProps().href;
+	const isTrigger = () => !!getProps()["aria-haspopup"];
+	const selectableItem = createSelectableItem(() => {
+		const p = getProps();
+		return {
+			key: p.key,
+			id: p.id ?? String(p.key),
+			isDisabled: isDisabled(),
+			isLink: isLink(),
+			href: p.href,
+			shouldSelectOnPressUp: true,
+			allowsDifferentPressOrigin: true,
+			linkBehavior: "none"
+		};
+	}, state, () => ref?.() ?? null);
+	const isFocused = () => selectableItem.isFocused();
+	const isSelected = () => {
+		return !isTrigger() && selectableItem.isSelected();
+	};
+	let interaction = null;
+	let isMenuPressActive = false;
+	let isDispatchingKeyboardClick = false;
+	let isDispatchingMenuSyntheticClick = false;
+	let selectionEventBeforeMenuPressUp = null;
+	let hasSelectionEventBeforeMenuPressUp = false;
+	let pendingSyntheticClickSelectionEvent = null;
+	let suppressNextKeyboardClick = false;
+	const getShouldClose = () => {
+		const explicitClose = getProps().closeOnSelect ?? getData()?.shouldCloseOnSelect;
+		if (explicitClose !== void 0) return explicitClose;
+		if (interaction?.pointerType === "keyboard") return interaction.key === "Enter" || selectionMode() === "none" || isLink();
+		return selectionMode() !== "multiple" || isLink();
+	};
+	const performMenuAction = (event) => {
+		if (isDisabled()) {
+			event.preventDefault();
+			return;
+		}
+		if (suppressNextKeyboardClick && interaction == null) {
+			suppressNextKeyboardClick = false;
+			return;
+		}
+		const p = getProps();
+		const key = p.key;
+		const data = getData();
+		if (isTrigger()) {
+			p.onAction?.();
+			interaction = null;
+			return;
+		}
+		p.onAction?.();
+		const item = state.collection().getItem(key);
+		data?.onAction?.(key, item?.value);
+		if (getShouldClose()) data?.onClose?.();
+		interaction = null;
+	};
+	const { pressProps, isPressed } = createPress({
+		get isDisabled() {
+			return isDisabled();
+		},
+		onPressChange(isPressed) {
+			isMenuPressActive = isPressed;
+		},
+		onPressUp(e) {
+			if (e.pointerType !== "keyboard" && !isDispatchingKeyboardClick) interaction = { pointerType: e.pointerType };
+			if (e.pointerType === "mouse" && !isMenuPressActive && e.target instanceof HTMLElement) {
+				const selectionEventAfterPressUp = state.selectionManager.lastSelectionEvent;
+				pendingSyntheticClickSelectionEvent = hasSelectionEventBeforeMenuPressUp && selectionEventAfterPressUp != null && selectionEventAfterPressUp !== selectionEventBeforeMenuPressUp ? selectionEventAfterPressUp : null;
+				isDispatchingMenuSyntheticClick = true;
+				try {
+					e.target.click();
+				} finally {
+					isDispatchingMenuSyntheticClick = false;
+					hasSelectionEventBeforeMenuPressUp = false;
+					selectionEventBeforeMenuPressUp = null;
+					pendingSyntheticClickSelectionEvent = null;
+				}
+			}
+		}
+	});
+	const captureSelectionEventBeforeMenuPressUp = () => {
+		selectionEventBeforeMenuPressUp = state.selectionManager.lastSelectionEvent;
+		hasSelectionEventBeforeMenuPressUp = true;
+	};
+	const withMenuPressUpSelectionSnapshot = (handler) => {
+		if (typeof handler !== "function") return handler;
+		return (event) => {
+			captureSelectionEventBeforeMenuPressUp();
+			handler(event);
+		};
+	};
+	const selectableItemProps = () => {
+		const props = selectableItem.itemProps;
+		const onClick = props.onClick;
+		return {
+			...props,
+			onPointerUp: withMenuPressUpSelectionSnapshot(props.onPointerUp),
+			onMouseUp: withMenuPressUpSelectionSnapshot(props.onMouseUp),
+			onClick: typeof onClick === "function" ? (event) => {
+				if (isDispatchingMenuSyntheticClick && isVirtualClick(event)) {
+					if (pendingSyntheticClickSelectionEvent != null) {
+						state.selectionManager.emitDuplicateSelectionEvent(pendingSyntheticClickSelectionEvent);
+						pendingSyntheticClickSelectionEvent = null;
+					}
+					return;
+				}
+				onClick(event);
+			} : onClick
+		};
+	};
+	const menuPressProps = () => {
+		const { onKeyDown: _onKeyDown, onKeyUp: _onKeyUp, ...props } = pressProps;
+		return props;
+	};
+	const keyboardProps = {
+		onKeyDown: (event) => {
+			if (isDisabled() || event.repeat) return;
+			if (event.key !== " " && event.key !== "Enter") return;
+			event.preventDefault();
+			event.stopPropagation();
+			interaction = {
+				pointerType: "keyboard",
+				key: event.key
+			};
+			const target = getEventTarget(event) ?? ref?.();
+			if (target instanceof HTMLElement) {
+				suppressNextKeyboardClick = true;
+				isDispatchingKeyboardClick = true;
+				try {
+					target.click();
+				} finally {
+					isDispatchingKeyboardClick = false;
+				}
+			}
+		},
+		onKeyUp: (event) => {
+			if (event.key === " " || event.key === "Enter") suppressNextKeyboardClick = false;
+		}
+	};
+	const { hoverProps } = createHover({
+		get isDisabled() {
+			return isDisabled();
+		},
+		onHoverStart() {
+			state.setFocusedKey(getProps().key);
+		}
+	});
+	const { isFocusVisible, focusProps } = createFocusRing();
+	const labelId = `${getProps().key}-label`;
+	const descriptionId = createSlotId();
+	const keyboardId = createSlotId();
+	return {
+		get menuItemProps() {
+			const p = getProps();
+			const key = p.key;
+			const ariaLabel = p["aria-label"];
+			const mode = selectionMode();
+			const selected = isSelected();
+			const trigger = isTrigger();
+			const baseProps = {
+				role: trigger ? "menuitem" : mode === "single" ? "menuitemradio" : mode === "multiple" ? "menuitemcheckbox" : "menuitem",
+				id: p.id ?? String(key),
+				"aria-disabled": isDisabled() || void 0,
+				"aria-checked": mode !== "none" && !trigger ? selected : void 0,
+				"aria-label": ariaLabel,
+				"aria-labelledby": !ariaLabel ? labelId : void 0,
+				"aria-describedby": [descriptionId(), keyboardId()].filter(Boolean).join(" ") || void 0,
+				"aria-controls": p["aria-controls"],
+				"aria-haspopup": p["aria-haspopup"],
+				"aria-expanded": p["aria-expanded"],
+				"data-selected": selected || void 0,
+				"data-focused": isFocused() || void 0,
+				"data-focus-visible": isFocusVisible() || void 0,
+				"data-pressed": isPressed() || void 0,
+				"data-disabled": isDisabled() || void 0
+			};
+			if (isLink()) {
+				baseProps.href = isDisabled() ? void 0 : p.href;
+				if (p.target) baseProps.target = p.target;
+				if (p.rel) baseProps.rel = p.rel;
+				if (p.download != null && p.download !== false) baseProps.download = p.download === true ? "" : p.download;
+			}
+			return mergeProps$1(selectableItemProps(), menuPressProps(), hoverProps, focusProps, keyboardProps, { onClick: performMenuAction }, baseProps);
+		},
+		labelProps: { id: labelId },
+		get descriptionProps() {
+			return { id: descriptionId() };
+		},
+		get keyboardShortcutProps() {
+			return {
+				id: keyboardId(),
+				"aria-hidden": true
+			};
+		},
+		isFocused,
+		isFocusVisible: () => isFocused() && isFocusVisible(),
+		isPressed,
+		isDisabled,
+		isSelected,
+		selectionMode
+	};
+}
+//#endregion
+//#region src/menu/createMenuTrigger.ts
+/**
+* Provides the behavior and accessibility implementation for a menu trigger.
+*/
+function createMenuTrigger(props, state) {
+	const getProps = () => access(props);
+	const menuId = createId(getProps().id);
+	const onPress = () => {
+		if (!getProps().isDisabled) state.toggle();
+	};
+	const onKeyDown = (e) => {
+		if (getProps().isDisabled) return;
+		switch (e.key) {
+			case "Enter":
+			case " ":
+			case "ArrowDown":
+				e.preventDefault();
+				if (!state.isOpen()) state.open();
+				break;
+			case "ArrowUp":
+				e.preventDefault();
+				if (!state.isOpen()) state.open();
+				break;
+		}
+	};
+	return {
+		get menuTriggerProps() {
+			const p = getProps();
+			const type = p.type ?? "menu";
+			const isOpen = state.isOpen();
+			return {
+				"aria-haspopup": type,
+				"aria-expanded": isOpen,
+				"aria-controls": isOpen ? menuId : void 0,
+				"aria-disabled": p.isDisabled || void 0,
+				onPress,
+				onKeyDown
+			};
+		},
+		menuProps: { id: menuId }
+	};
+}
+//#endregion
+export { getMenuData as i, createMenuItem as n, createMenu as r, createMenuTrigger as t };
+
+//# sourceMappingURL=menu.js.map