@lucasbernardosn/react-ui 0.0.0-stage → 0.1.0

package/dist/components/overlays/menu/menu-popup.d.ts

@@ -0,0 +1,22 @@
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-popup.d.ts
+export type MenuPopupProps = Menu.Popup.Props;
+export type MenuPopupState = Menu.Popup.State;
+/**
+ * Caixa dos itens, com `role="menu"`. Tem no mínimo 8rem de largura e cresce com o texto dos
+ * itens; acima do espaço livre na tela, ela mesma rola.
+ *
+ * Cópia de `popoverPopupVariants`, a origem da superfície dos popups, onde fundo, contorno,
+ * sombra, cor do texto e animação estão explicados (tabela no README de `overlays`). As
+ * diferenças:
+ * - sem `--popover-padding` nem coluna flex: o popup é uma lista, com `py-1` acima e abaixo dos
+ *   itens, e o realce de cada item já recua das laterais;
+ * - largura mínima `min-w-32`;
+ * - rola por inteiro (`overflow-y-auto`), e não por um `Body`.
+ */
+export declare const MenuPopup: {
+  (props: MenuPopupProps): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=menu-popup.d.ts.map

package/dist/components/overlays/menu/menu-popup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-popup.d.ts","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-popup.tsx"],"mappings":";;YAGY,iBAAiBA,KAAS,MAAM;YAEhC,iBAAiBA,KAAS,MAAM;;;;;;;;;;;;;qBAc/B;GAAoB,OAAA,iCAAc,IAAA"}

package/dist/components/overlays/menu/menu-popup.js

@@ -0,0 +1,61 @@
+import { mergeStateClassNames } from "../../../utils/merge-state-class-names.js";
+import { jsx } from "react/jsx-runtime";
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-popup.tsx
+/**
+* Caixa dos itens, com `role="menu"`. Tem no mínimo 8rem de largura e cresce com o texto dos
+* itens; acima do espaço livre na tela, ela mesma rola.
+*
+* Cópia de `popoverPopupVariants`, a origem da superfície dos popups, onde fundo, contorno,
+* sombra, cor do texto e animação estão explicados (tabela no README de `overlays`). As
+* diferenças:
+* - sem `--popover-padding` nem coluna flex: o popup é uma lista, com `py-1` acima e abaixo dos
+*   itens, e o realce de cada item já recua das laterais;
+* - largura mínima `min-w-32`;
+* - rola por inteiro (`overflow-y-auto`), e não por um `Body`.
+*/
+const MenuPopup = (props) => {
+	const { className, ...rest } = props;
+	return /* @__PURE__ */ jsx(Menu.Popup, {
+		"data-component": "Menu.Popup",
+		className: mergeStateClassNames([
+			"relative",
+			"h-(--popup-height,auto)",
+			"w-(--popup-width,auto)",
+			"max-h-(--available-height)",
+			"min-w-32",
+			"max-w-[min(calc(100dvw-1rem),var(--container-md))]",
+			"py-1",
+			"scroll-py-1",
+			"overflow-y-auto",
+			"rounded-md",
+			"corner-squircle",
+			"outline-1",
+			"outline-gray-6",
+			"bg-white",
+			"dark:bg-gray-2",
+			"shadow-md",
+			"shadow-black/12",
+			"dark:shadow-none",
+			"text-sm",
+			"text-gray-12",
+			"not-motion-reduced:origin-(--transform-origin)",
+			"not-motion-reduced:transition-[width,height,opacity,scale]",
+			"not-motion-reduced:ease-enter",
+			"not-motion-reduced:duration-150",
+			"not-motion-reduced:data-starting-style:scale-95",
+			"not-motion-reduced:data-ending-style:scale-95",
+			"not-motion-reduced:data-ending-style:ease-exit",
+			"not-motion-reduced:data-ending-style:duration-100",
+			"data-starting-style:opacity-0",
+			"data-ending-style:opacity-0",
+			"data-instant:transition-none"
+		], className),
+		...rest
+	});
+};
+MenuPopup.displayName = "Menu.Popup";
+//#endregion
+export { MenuPopup };
+
+//# sourceMappingURL=menu-popup.js.map

package/dist/components/overlays/menu/menu-popup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-popup.js","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-popup.tsx"],"sourcesContent":["import { Menu as BaseMenu } from '@base-ui/react/menu';\nimport { mergeStateClassNames } from '#utils';\n\nexport type MenuPopupProps = BaseMenu.Popup.Props;\n\nexport type MenuPopupState = BaseMenu.Popup.State;\n\n/**\n * Caixa dos itens, com `role=\"menu\"`. Tem no mínimo 8rem de largura e cresce com o texto dos\n * itens; acima do espaço livre na tela, ela mesma rola.\n *\n * Cópia de `popoverPopupVariants`, a origem da superfície dos popups, onde fundo, contorno,\n * sombra, cor do texto e animação estão explicados (tabela no README de `overlays`). As\n * diferenças:\n * - sem `--popover-padding` nem coluna flex: o popup é uma lista, com `py-1` acima e abaixo dos\n *   itens, e o realce de cada item já recua das laterais;\n * - largura mínima `min-w-32`;\n * - rola por inteiro (`overflow-y-auto`), e não por um `Body`.\n */\nexport const MenuPopup = (props: MenuPopupProps) => {\n  const { className, ...rest } = props;\n\n  return (\n    <BaseMenu.Popup\n      data-component=\"Menu.Popup\"\n      className={mergeStateClassNames(\n        [\n          'relative',\n\n          'h-(--popup-height,auto)',\n          'w-(--popup-width,auto)',\n\n          'max-h-(--available-height)',\n          'min-w-32',\n          // Teto fixo, não por tamanho de tela: no celular vale a largura da tela menos um respiro.\n          'max-w-[min(calc(100dvw-1rem),var(--container-md))]',\n\n          'py-1',\n          'scroll-py-1',\n\n          'overflow-y-auto',\n\n          'rounded-md',\n          'corner-squircle',\n          'outline-1',\n          'outline-gray-6',\n\n          'bg-white',\n          'dark:bg-gray-2',\n\n          'shadow-md',\n          'shadow-black/12',\n          'dark:shadow-none',\n\n          // O popup vai para o `body` pelo portal: sem cor própria, o texto herdaria a do navegador.\n          'text-sm',\n          'text-gray-12',\n\n          'not-motion-reduced:origin-(--transform-origin)',\n          'not-motion-reduced:transition-[width,height,opacity,scale]',\n          'not-motion-reduced:ease-enter',\n          'not-motion-reduced:duration-150',\n\n          'not-motion-reduced:data-starting-style:scale-95',\n          'not-motion-reduced:data-ending-style:scale-95',\n          'not-motion-reduced:data-ending-style:ease-exit',\n          'not-motion-reduced:data-ending-style:duration-100',\n          'data-starting-style:opacity-0',\n          'data-ending-style:opacity-0',\n\n          'data-instant:transition-none',\n        ],\n        className,\n      )}\n      {...rest}\n    />\n  );\n};\n\nMenuPopup.displayName = 'Menu.Popup';\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,MAAa,aAAa,UAA0B;CAClD,MAAM,EAAE,WAAW,GAAG,SAAS;CAE/B,OACE,oBAACA,KAAS,OAAV;EACE,kBAAe;EACf,WAAW,qBACT;GACE;GAEA;GACA;GAEA;GACA;GAEA;GAEA;GACA;GAEA;GAEA;GACA;GACA;GACA;GAEA;GACA;GAEA;GACA;GACA;GAGA;GACA;GAEA;GACA;GACA;GACA;GAEA;GACA;GACA;GACA;GACA;GACA;GAEA;EACF,GACA,SACF;EACA,GAAI;CACL,CAAA;AAEL;AAEA,UAAU,cAAc"}

package/dist/components/overlays/menu/menu-portal.d.ts

@@ -0,0 +1,13 @@
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-portal.d.ts
+export type MenuPortalProps = Menu.Portal.Props;
+export type MenuPortalState = Menu.Portal.State;
+/**
+ * Leva o menu para o fim do `body`, fora do contexto de empilhamento do trigger.
+ */
+export declare const MenuPortal: {
+  (props: MenuPortalProps): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=menu-portal.d.ts.map

package/dist/components/overlays/menu/menu-portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-portal.d.ts","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-portal.tsx"],"mappings":";;YAEY,kBAAkBA,KAAS,OAAO;YAElC,kBAAkBA,KAAS,OAAO;;;;qBAKjC;GAAqB,OAAA,kCAAe,IAAA"}

package/dist/components/overlays/menu/menu-portal.js

@@ -0,0 +1,17 @@
+import { jsx } from "react/jsx-runtime";
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-portal.tsx
+/**
+* Leva o menu para o fim do `body`, fora do contexto de empilhamento do trigger.
+*/
+const MenuPortal = (props) => {
+	return /* @__PURE__ */ jsx(Menu.Portal, {
+		"data-component": "Menu.Portal",
+		...props
+	});
+};
+MenuPortal.displayName = "Menu.Portal";
+//#endregion
+export { MenuPortal };
+
+//# sourceMappingURL=menu-portal.js.map

package/dist/components/overlays/menu/menu-portal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-portal.js","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-portal.tsx"],"sourcesContent":["import { Menu as BaseMenu } from '@base-ui/react/menu';\n\nexport type MenuPortalProps = BaseMenu.Portal.Props;\n\nexport type MenuPortalState = BaseMenu.Portal.State;\n\n/**\n * Leva o menu para o fim do `body`, fora do contexto de empilhamento do trigger.\n */\nexport const MenuPortal = (props: MenuPortalProps) => {\n  return (\n    <BaseMenu.Portal\n      data-component=\"Menu.Portal\"\n      {...props}\n    />\n  );\n};\n\nMenuPortal.displayName = 'Menu.Portal';\n"],"mappings":";;;;;;AASA,MAAa,cAAc,UAA2B;CACpD,OACE,oBAACA,KAAS,QAAV;EACE,kBAAe;EACf,GAAI;CACL,CAAA;AAEL;AAEA,WAAW,cAAc"}

package/dist/components/overlays/menu/menu-positioner.d.ts

@@ -0,0 +1,18 @@
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-positioner.d.ts
+export type MenuPositionerProps = Menu.Positioner.Props;
+export type MenuPositionerState = Menu.Positioner.State;
+/**
+ * Posiciona o menu junto ao trigger, embaixo e alinhado à borda inicial dele (`align="start"`):
+ * centralizado, como no padrão do Base UI, o menu de um botão largo abriria longe do ponto
+ * clicado.
+ *
+ * Cópia do `Popover.Positioner`, a origem do positioner dos popups, onde o deslize entre
+ * triggers está explicado (tabela no README de `overlays`). A diferença é o `align="start"`.
+ */
+export declare const MenuPositioner: {
+  (props: MenuPositionerProps): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=menu-positioner.d.ts.map

package/dist/components/overlays/menu/menu-positioner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-positioner.d.ts","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-positioner.tsx"],"mappings":";;YAGY,sBAAsBA,KAAS,WAAW;YAE1C,sBAAsBA,KAAS,WAAW;;;;;;;;;qBAUzC;GAAyB,OAAA,sCAAmB,IAAA"}

package/dist/components/overlays/menu/menu-positioner.js

@@ -0,0 +1,36 @@
+import { mergeStateClassNames } from "../../../utils/merge-state-class-names.js";
+import { jsx } from "react/jsx-runtime";
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-positioner.tsx
+/**
+* Posiciona o menu junto ao trigger, embaixo e alinhado à borda inicial dele (`align="start"`):
+* centralizado, como no padrão do Base UI, o menu de um botão largo abriria longe do ponto
+* clicado.
+*
+* Cópia do `Popover.Positioner`, a origem do positioner dos popups, onde o deslize entre
+* triggers está explicado (tabela no README de `overlays`). A diferença é o `align="start"`.
+*/
+const MenuPositioner = (props) => {
+	const { className, ...rest } = props;
+	return /* @__PURE__ */ jsx(Menu.Positioner, {
+		"data-component": "Menu.Positioner",
+		className: mergeStateClassNames([
+			"w-(--positioner-width)",
+			"h-(--positioner-height)",
+			"max-w-(--available-width)",
+			"not-motion-reduced:transition-[top,left,right,bottom,transform]",
+			"not-motion-reduced:duration-200",
+			"not-motion-reduced:ease-move",
+			"data-instant:transition-none"
+		], className),
+		sideOffset: 6,
+		collisionPadding: 12,
+		align: "start",
+		...rest
+	});
+};
+MenuPositioner.displayName = "Menu.Positioner";
+//#endregion
+export { MenuPositioner };
+
+//# sourceMappingURL=menu-positioner.js.map

package/dist/components/overlays/menu/menu-positioner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-positioner.js","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-positioner.tsx"],"sourcesContent":["import { Menu as BaseMenu } from '@base-ui/react/menu';\nimport { mergeStateClassNames } from '#utils';\n\nexport type MenuPositionerProps = BaseMenu.Positioner.Props;\n\nexport type MenuPositionerState = BaseMenu.Positioner.State;\n\n/**\n * Posiciona o menu junto ao trigger, embaixo e alinhado à borda inicial dele (`align=\"start\"`):\n * centralizado, como no padrão do Base UI, o menu de um botão largo abriria longe do ponto\n * clicado.\n *\n * Cópia do `Popover.Positioner`, a origem do positioner dos popups, onde o deslize entre\n * triggers está explicado (tabela no README de `overlays`). A diferença é o `align=\"start\"`.\n */\nexport const MenuPositioner = (props: MenuPositionerProps) => {\n  const { className, ...rest } = props;\n\n  return (\n    <BaseMenu.Positioner\n      data-component=\"Menu.Positioner\"\n      className={mergeStateClassNames(\n        [\n          'w-(--positioner-width)',\n          'h-(--positioner-height)',\n          'max-w-(--available-width)',\n\n          'not-motion-reduced:transition-[top,left,right,bottom,transform]',\n          'not-motion-reduced:duration-200',\n          'not-motion-reduced:ease-move',\n\n          'data-instant:transition-none',\n        ],\n        className,\n      )}\n      sideOffset={6}\n      collisionPadding={12}\n      align=\"start\"\n      {...rest}\n    />\n  );\n};\n\nMenuPositioner.displayName = 'Menu.Positioner';\n"],"mappings":";;;;;;;;;;;;AAeA,MAAa,kBAAkB,UAA+B;CAC5D,MAAM,EAAE,WAAW,GAAG,SAAS;CAE/B,OACE,oBAACA,KAAS,YAAV;EACE,kBAAe;EACf,WAAW,qBACT;GACE;GACA;GACA;GAEA;GACA;GACA;GAEA;EACF,GACA,SACF;EACA,YAAY;EACZ,kBAAkB;EAClB,OAAM;EACN,GAAI;CACL,CAAA;AAEL;AAEA,eAAe,cAAc"}

package/dist/components/overlays/menu/menu-root.d.ts

@@ -0,0 +1,35 @@
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-root.d.ts
+export type MenuRootProps<Payload = unknown> = Menu.Root.Props<Payload>;
+export type MenuRootState = Menu.Root.State;
+export type MenuRootActions = Menu.Root.Actions;
+export type MenuRootChangeEventDetails = Menu.Root.ChangeEventDetails;
+export type MenuRootChangeEventReason = Menu.Root.ChangeEventReason;
+/**
+ * Estado do menu. Não renderiza elemento.
+ *
+ * @example
+ * ```tsx
+ * <Menu.Root>
+ *   <Menu.Trigger render={<Button />}>Ações</Menu.Trigger>
+ *   <Menu.Portal>
+ *     <Menu.Positioner>
+ *       <Menu.Popup>
+ *         <Menu.Item onClick={edit}>Editar</Menu.Item>
+ *         <Menu.Item onClick={duplicate}>Duplicar</Menu.Item>
+ *         <Menu.Separator />
+ *         <Menu.Item colorScheme="red" onClick={remove}>
+ *           Excluir
+ *         </Menu.Item>
+ *       </Menu.Popup>
+ *     </Menu.Positioner>
+ *   </Menu.Portal>
+ * </Menu.Root>
+ * ```
+ */
+export declare const MenuRoot: {
+  <Payload extends unknown = unknown>(props: MenuRootProps<Payload>): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=menu-root.d.ts.map

package/dist/components/overlays/menu/menu-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-root.d.ts","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-root.tsx"],"mappings":";;YAGY,cAAc,qBAAqBA,KAAS,KAAK,MAAM;YAEvD,gBAAgBA,KAAS,KAAK;YAE9B,kBAAkBA,KAAS,KAAK;YAEhC,6BAA6BA,KAAS,KAAK;YAE3C,4BAA4BA,KAAS,KAAK;;;;;;;;;;;;;;;;;;;;;;;qBAwBzC;GAAY,mCAAO,OACvB,cAAc,2BAAQ,IAAA"}

package/dist/components/overlays/menu/menu-root.js

@@ -0,0 +1,33 @@
+import { jsx } from "react/jsx-runtime";
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-root.tsx
+/**
+* Estado do menu. Não renderiza elemento.
+*
+* @example
+* ```tsx
+* <Menu.Root>
+*   <Menu.Trigger render={<Button />}>Ações</Menu.Trigger>
+*   <Menu.Portal>
+*     <Menu.Positioner>
+*       <Menu.Popup>
+*         <Menu.Item onClick={edit}>Editar</Menu.Item>
+*         <Menu.Item onClick={duplicate}>Duplicar</Menu.Item>
+*         <Menu.Separator />
+*         <Menu.Item colorScheme="red" onClick={remove}>
+*           Excluir
+*         </Menu.Item>
+*       </Menu.Popup>
+*     </Menu.Positioner>
+*   </Menu.Portal>
+* </Menu.Root>
+* ```
+*/
+const MenuRoot = (props) => {
+	return /* @__PURE__ */ jsx(Menu.Root, { ...props });
+};
+MenuRoot.displayName = "Menu.Root";
+//#endregion
+export { MenuRoot };
+
+//# sourceMappingURL=menu-root.js.map

package/dist/components/overlays/menu/menu-root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-root.js","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-root.tsx"],"sourcesContent":["import { Menu as BaseMenu } from '@base-ui/react/menu';\nimport type { AnyType } from '@lucasbernardosn/utils';\n\nexport type MenuRootProps<Payload = unknown> = BaseMenu.Root.Props<Payload>;\n\nexport type MenuRootState = BaseMenu.Root.State;\n\nexport type MenuRootActions = BaseMenu.Root.Actions;\n\nexport type MenuRootChangeEventDetails = BaseMenu.Root.ChangeEventDetails;\n\nexport type MenuRootChangeEventReason = BaseMenu.Root.ChangeEventReason;\n\n/**\n * Estado do menu. Não renderiza elemento.\n *\n * @example\n * ```tsx\n * <Menu.Root>\n *   <Menu.Trigger render={<Button />}>Ações</Menu.Trigger>\n *   <Menu.Portal>\n *     <Menu.Positioner>\n *       <Menu.Popup>\n *         <Menu.Item onClick={edit}>Editar</Menu.Item>\n *         <Menu.Item onClick={duplicate}>Duplicar</Menu.Item>\n *         <Menu.Separator />\n *         <Menu.Item colorScheme=\"red\" onClick={remove}>\n *           Excluir\n *         </Menu.Item>\n *       </Menu.Popup>\n *     </Menu.Positioner>\n *   </Menu.Portal>\n * </Menu.Root>\n * ```\n */\nexport const MenuRoot = <Payload extends AnyType = unknown>(\n  props: MenuRootProps<Payload>,\n) => {\n  return <BaseMenu.Root {...props} />;\n};\n\nMenuRoot.displayName = 'Menu.Root';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,MAAa,YACX,UACG;CACH,OAAO,oBAACA,KAAS,MAAV,EAAe,GAAI,MAAQ,CAAA;AACpC;AAEA,SAAS,cAAc"}

package/dist/components/overlays/menu/menu-separator.d.ts

@@ -0,0 +1,15 @@
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-separator.d.ts
+export type MenuSeparatorProps = Menu.Separator.Props;
+export type MenuSeparatorState = Menu.Separator.State;
+/**
+ * Linha entre itens ou grupos. O Base UI escreve `role="separator"`.
+ *
+ * Cópia do `Select.Separator` (tabela no README de `collections`), sem diferenças.
+ */
+export declare const MenuSeparator: {
+  (props: MenuSeparatorProps): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=menu-separator.d.ts.map

package/dist/components/overlays/menu/menu-separator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-separator.d.ts","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-separator.tsx"],"mappings":";;YAGY,qBAAqBA,KAAS,UAAU;YAExC,qBAAqBA,KAAS,UAAU;;;;;;qBAOvC;GAAwB,OAAA,qCAAkB,IAAA"}

package/dist/components/overlays/menu/menu-separator.js

@@ -0,0 +1,27 @@
+import { mergeStateClassNames } from "../../../utils/merge-state-class-names.js";
+import { jsx } from "react/jsx-runtime";
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-separator.tsx
+/**
+* Linha entre itens ou grupos. O Base UI escreve `role="separator"`.
+*
+* Cópia do `Select.Separator` (tabela no README de `collections`), sem diferenças.
+*/
+const MenuSeparator = (props) => {
+	const { className, ...rest } = props;
+	return /* @__PURE__ */ jsx(Menu.Separator, {
+		"data-component": "Menu.Separator",
+		className: mergeStateClassNames([
+			"h-px",
+			"my-1",
+			"mx-2",
+			"bg-gray-6"
+		], className),
+		...rest
+	});
+};
+MenuSeparator.displayName = "Menu.Separator";
+//#endregion
+export { MenuSeparator };
+
+//# sourceMappingURL=menu-separator.js.map

package/dist/components/overlays/menu/menu-separator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-separator.js","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-separator.tsx"],"sourcesContent":["import { Menu as BaseMenu } from '@base-ui/react/menu';\nimport { mergeStateClassNames } from '#utils';\n\nexport type MenuSeparatorProps = BaseMenu.Separator.Props;\n\nexport type MenuSeparatorState = BaseMenu.Separator.State;\n\n/**\n * Linha entre itens ou grupos. O Base UI escreve `role=\"separator\"`.\n *\n * Cópia do `Select.Separator` (tabela no README de `collections`), sem diferenças.\n */\nexport const MenuSeparator = (props: MenuSeparatorProps) => {\n  const { className, ...rest } = props;\n\n  return (\n    <BaseMenu.Separator\n      data-component=\"Menu.Separator\"\n      className={mergeStateClassNames(\n        [\n          'h-px',\n\n          'my-1',\n          'mx-2',\n\n          'bg-gray-6',\n        ],\n        className,\n      )}\n      {...rest}\n    />\n  );\n};\n\nMenuSeparator.displayName = 'Menu.Separator';\n"],"mappings":";;;;;;;;;AAYA,MAAa,iBAAiB,UAA8B;CAC1D,MAAM,EAAE,WAAW,GAAG,SAAS;CAE/B,OACE,oBAACA,KAAS,WAAV;EACE,kBAAe;EACf,WAAW,qBACT;GACE;GAEA;GACA;GAEA;EACF,GACA,SACF;EACA,GAAI;CACL,CAAA;AAEL;AAEA,cAAc,cAAc"}

package/dist/components/overlays/menu/menu-trigger.d.ts

@@ -0,0 +1,14 @@
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-trigger.d.ts
+export type MenuTriggerProps<Payload = unknown> = Menu.Trigger.Props<Payload>;
+export type MenuTriggerState = Menu.Trigger.State;
+/**
+ * Botão que abre o menu. Sem estilo próprio; passe um botão da lib em `render`. Enquanto o menu
+ * está aberto, o Base UI marca o trigger com `data-popup-open`.
+ */
+export declare const MenuTrigger: {
+  <Payload extends unknown = unknown>(props: MenuTriggerProps<Payload>): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=menu-trigger.d.ts.map

package/dist/components/overlays/menu/menu-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-trigger.d.ts","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-trigger.tsx"],"mappings":";;YAIY,iBAAiB,qBAC3BA,KAAS,QAAQ,MAAM;YAEb,mBAAmBA,KAAS,QAAQ;;;;;qBAMnC;GAAe,mCAAO,OAC1B,iBAAiB,2BAAQ,IAAA"}

package/dist/components/overlays/menu/menu-trigger.js

@@ -0,0 +1,21 @@
+import { mergeStateClassNames } from "../../../utils/merge-state-class-names.js";
+import { jsx } from "react/jsx-runtime";
+import { Menu } from "@base-ui/react/menu";
+//#region src/components/overlays/menu/menu-trigger.tsx
+/**
+* Botão que abre o menu. Sem estilo próprio; passe um botão da lib em `render`. Enquanto o menu
+* está aberto, o Base UI marca o trigger com `data-popup-open`.
+*/
+const MenuTrigger = (props) => {
+	const { className, ...rest } = props;
+	return /* @__PURE__ */ jsx(Menu.Trigger, {
+		"data-component": "Menu.Trigger",
+		className: mergeStateClassNames([], className),
+		...rest
+	});
+};
+MenuTrigger.displayName = "Menu.Trigger";
+//#endregion
+export { MenuTrigger };
+
+//# sourceMappingURL=menu-trigger.js.map

package/dist/components/overlays/menu/menu-trigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-trigger.js","names":["BaseMenu"],"sources":["../../../../src/components/overlays/menu/menu-trigger.tsx"],"sourcesContent":["import { Menu as BaseMenu } from '@base-ui/react/menu';\nimport type { AnyType } from '@lucasbernardosn/utils';\nimport { mergeStateClassNames } from '#utils';\n\nexport type MenuTriggerProps<Payload = unknown> =\n  BaseMenu.Trigger.Props<Payload>;\n\nexport type MenuTriggerState = BaseMenu.Trigger.State;\n\n/**\n * Botão que abre o menu. Sem estilo próprio; passe um botão da lib em `render`. Enquanto o menu\n * está aberto, o Base UI marca o trigger com `data-popup-open`.\n */\nexport const MenuTrigger = <Payload extends AnyType = unknown>(\n  props: MenuTriggerProps<Payload>,\n) => {\n  const { className, ...rest } = props;\n\n  return (\n    <BaseMenu.Trigger\n      data-component=\"Menu.Trigger\"\n      className={mergeStateClassNames([], className)}\n      {...rest}\n    />\n  );\n};\n\nMenuTrigger.displayName = 'Menu.Trigger';\n"],"mappings":";;;;;;;;AAaA,MAAa,eACX,UACG;CACH,MAAM,EAAE,WAAW,GAAG,SAAS;CAE/B,OACE,oBAACA,KAAS,SAAV;EACE,kBAAe;EACf,WAAW,qBAAqB,CAAC,GAAG,SAAS;EAC7C,GAAI;CACL,CAAA;AAEL;AAEA,YAAY,cAAc"}

package/dist/components/overlays/overlay-manager/index.d.ts

@@ -0,0 +1,2 @@
+import { Overlay, OverlayHandle, OverlayOutlet, OverlayRender, createOverlay, overlays } from "./overlay-manager.js";
+export { Overlay, OverlayHandle, OverlayOutlet, OverlayRender, createOverlay, overlays };

package/dist/components/overlays/overlay-manager/index.js

@@ -0,0 +1,2 @@
+import { OverlayOutlet, createOverlay, overlays } from "./overlay-manager.js";
+export { OverlayOutlet, createOverlay, overlays };

package/dist/components/overlays/overlay-manager/overlay-manager.d.ts

@@ -0,0 +1,49 @@
+import React from "react";
+import { StrictEmptyObject } from "@lucasbernardosn/utils";
+//#region src/components/overlays/overlay-manager/overlay-manager.d.ts
+/** Handle entregue ao `render` (2º argumento). Só existe de dentro do overlay. */
+export type OverlayHandle<Result = void> = {
+  /**
+   * Ligue no `open` do popup. `false` no primeiro render, `true` no commit
+   * seguinte (para a transição de entrada rodar), `false` de novo em `close()`.
+   */
+  readonly open: boolean;
+  /**
+   * Resolve a promise de `show()` com `value` (ou `undefined`) e começa a
+   * fechar. Idempotente: a primeira chamada vence.
+   */
+  close: (value?: Result) => void;
+  /**
+   * Remove a instância da árvore React. Chame quando a transição de saída
+   * terminar — normalmente de `onOpenChangeComplete`.
+   */
+  unmount: () => void;
+};
+export type OverlayRender<Props, Result> = (props: Props, overlay: OverlayHandle<Result>) => React.ReactNode;
+type OpenArgs<Props> = StrictEmptyObject extends Props ? [props?: Props] : [props: Props];
+/** O que `createOverlay` devolve. */
+export type Overlay<Props, Result> = {
+  /**
+   * Abre o overlay. Cada chamada empilha uma instância nova. A promise resolve
+   * com o valor de `overlay.close(value)`, ou `undefined` se foi dispensado
+   * (`close()` sem valor, remoção, ou desmonte da árvore). Nunca rejeita.
+   */
+  show: (...args: OpenArgs<Props>) => Promise<Result | undefined>;
+};
+export declare function createOverlay<Props extends object = StrictEmptyObject, Result = void>(render: OverlayRender<Props, Result>): Overlay<Props, Result>;
+/**
+ * Renderiza os overlays abertos por `createOverlay(...).show()`. Monte uma única
+ * vez, perto do root, abaixo dos seus providers globais (tema, query client) —
+ * os overlays herdam o contexto daqui. Não renderiza HTML próprio.
+ */
+export declare function OverlayOutlet(): React.ReactNode;
+export declare const overlays: {
+  /**
+   * Remove todas as instâncias imediatamente, sem transição de saída. As
+   * promises de `show()` ainda pendentes resolvem com `undefined`. Use em
+   * mudança de rota.
+   */
+  closeAll(): void;
+};
+//#endregion
+//# sourceMappingURL=overlay-manager.d.ts.map

package/dist/components/overlays/overlay-manager/overlay-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-manager.d.ts","names":[],"sources":["../../../../src/components/overlays/overlay-manager/overlay-manager.tsx"],"mappings":";;;;YAmDY,cAAc;;;;;WAKf;;;;;EAKT,QAAQ,QAAQ;;;;;EAKhB;;YAGU,cAAc,OAAO,WAC/B,OAAO,OACP,SAAS,cAAc,YACpB,MAAM;KAEN,SAAS,SAAS,0BAA0B,SAC5C,QAAQ,UACR,OAAO;;YAGA,QAAQ,OAAO;;;;;;EAMzB,UAAU,MAAM,SAAS,WAAW,QAAQ;;wBAuK9B,cACd,uBAAuB,mBACvB,eACA,QAAQ,cAAc,OAAO,UAAU,QAAQ,OAAO;;;;;;wBA0FxC,iBAAiB,MAAM;qBA2B1B;;;;;;EAMC"}

package/dist/components/overlays/overlay-manager/overlay-manager.js

@@ -0,0 +1,182 @@
+"use client";
+import React, { memo, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { generateId } from "@base-ui/utils/generateId";
+import { useIsoLayoutEffect } from "@base-ui/utils/useIsoLayoutEffect";
+import { useStableCallback } from "@base-ui/utils/useStableCallback";
+import { useTimeout } from "@base-ui/utils/useTimeout";
+//#region src/components/overlays/overlay-manager/overlay-manager.tsx
+/** Quanto tempo um overlay pode ficar fechado e ainda montado antes do aviso. */
+const STALE_MOUNT_WARNING_DELAY = 3e3;
+/**
+* Estado global dos overlays vivos. Instância única (`store`), criada no load do
+* módulo. As instâncias são tratadas como snapshots imutáveis: cada mutação
+* troca o objeto afetado e o array, para os consumidores de `useSyncExternalStore`
+* re-renderizarem.
+*/
+var OverlayStore = class {
+	instances = [];
+	listeners = /* @__PURE__ */ new Set();
+	outletCount = 0;
+	/** Assinatura para `useSyncExternalStore`. */
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+	/** Snapshot para `useSyncExternalStore`. Ref estável entre mutações. */
+	getSnapshot = () => this.instances;
+	/** Adiciona uma instância nova (uma por `show()`). */
+	add = (instance) => {
+		this.instances = this.instances.concat(instance);
+		this.emit();
+		queueMicrotask(() => {
+			if (this.outletCount === 0 && this.instances.some((entry) => entry.id === instance.id)) console.error("OverlayManager: um overlay foi aberto mas nenhum <OverlayOutlet /> está montado, então ele não vai renderizar. Monte um único <OverlayOutlet /> perto do root da aplicação.");
+		});
+	};
+	/** Resolve a promise e começa a fechar (o popup anima a saída). */
+	close = (id, value) => {
+		const instance = this.instances.find((entry) => entry.id === id);
+		if (!instance) return;
+		instance.settle(value);
+		this.setOpen(id, false);
+	};
+	/** Tira a instância da árvore. Resolve com `undefined` se ainda não resolveu. */
+	remove = (id) => {
+		const instance = this.instances.find((entry) => entry.id === id);
+		if (!instance) return;
+		instance.settle(void 0);
+		this.instances = this.instances.filter((entry) => entry.id !== id);
+		this.emit();
+	};
+	/** Remove todas as instâncias na hora, resolvendo cada promise com `undefined`. */
+	closeAll = () => {
+		const settling = this.instances;
+		if (settling.length === 0) return;
+		this.instances = [];
+		this.emit();
+		settling.forEach((instance) => {
+			instance.settle(void 0);
+		});
+	};
+	/** O `<OverlayOutlet>` chama isto ao montar; devolve o cleanup. */
+	registerOutlet = () => {
+		this.outletCount += 1;
+		if (this.outletCount > 1) console.error("OverlayManager: mais de um <OverlayOutlet /> está montado. Renderize apenas um, perto do root da aplicação.");
+		return () => {
+			this.outletCount -= 1;
+		};
+	};
+	setOpen(id, open) {
+		this.instances = this.instances.map((instance) => instance.id === id ? {
+			...instance,
+			open
+		} : instance);
+		this.emit();
+	}
+	emit() {
+		this.listeners.forEach((listener) => {
+			listener();
+		});
+	}
+};
+const store = new OverlayStore();
+var OverlayErrorBoundary = class extends React.Component {
+	state = { errored: false };
+	static getDerivedStateFromError() {
+		return { errored: true };
+	}
+	componentDidCatch(error) {
+		console.error("OverlayManager: um overlay lançou durante o render e foi removido da árvore.\n", error);
+		store.remove(this.props.instanceId);
+	}
+	render() {
+		return this.state.errored ? null : this.props.children;
+	}
+};
+function createOverlay(render) {
+	function OverlayComponent({ instance }) {
+		const [entered, setEntered] = useState(false);
+		useIsoLayoutEffect(() => {
+			setEntered(true);
+		}, []);
+		const idRef = useRef(instance.id);
+		useIsoLayoutEffect(() => () => store.remove(idRef.current), []);
+		const staleTimeout = useTimeout();
+		useIsoLayoutEffect(() => {
+			if (instance.open) return;
+			staleTimeout.start(STALE_MOUNT_WARNING_DELAY, () => {
+				console.warn("OverlayManager: um overlay está fechado há um tempo mas continua montado. Chame overlay.unmount() quando a transição de saída terminar (normalmente no onOpenChangeComplete).");
+			});
+			return () => {
+				staleTimeout.clear();
+			};
+		}, [instance.open, staleTimeout]);
+		const close = useStableCallback((value) => {
+			store.close(instance.id, value);
+		});
+		const unmount = useStableCallback(() => {
+			store.remove(instance.id);
+		});
+		const open = entered && instance.open;
+		const overlay = useMemo(() => ({
+			open,
+			close,
+			unmount
+		}), [
+			open,
+			close,
+			unmount
+		]);
+		return render(instance.props, overlay);
+	}
+	const MemoOverlayComponent = memo(OverlayComponent);
+	MemoOverlayComponent.displayName = `Overlay(${render.name || "Anonymous"})`;
+	return { show: (...args) => {
+		let settled = false;
+		let resolvePromise;
+		const promise = new Promise((resolve) => {
+			resolvePromise = resolve;
+		});
+		store.add({
+			id: generateId("overlay"),
+			Component: MemoOverlayComponent,
+			props: args[0] ?? {},
+			open: true,
+			settle: (value) => {
+				if (!settled) {
+					settled = true;
+					resolvePromise(value);
+				}
+			}
+		});
+		return promise;
+	} };
+}
+/**
+* Renderiza os overlays abertos por `createOverlay(...).show()`. Monte uma única
+* vez, perto do root, abaixo dos seus providers globais (tema, query client) —
+* os overlays herdam o contexto daqui. Não renderiza HTML próprio.
+*/
+function OverlayOutlet() {
+	const list = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+	useIsoLayoutEffect(() => store.registerOutlet(), []);
+	return /* @__PURE__ */ jsx(Fragment, { children: list.map((instance) => /* @__PURE__ */ jsx(OverlayErrorBoundary, {
+		instanceId: instance.id,
+		children: /* @__PURE__ */ jsx(instance.Component, { instance })
+	}, instance.id)) });
+}
+const overlays = { 
+/**
+* Remove todas as instâncias imediatamente, sem transição de saída. As
+* promises de `show()` ainda pendentes resolvem com `undefined`. Use em
+* mudança de rota.
+*/
+closeAll() {
+	store.closeAll();
+} };
+//#endregion
+export { OverlayOutlet, createOverlay, overlays };
+
+//# sourceMappingURL=overlay-manager.js.map