@korsolutions/ui 0.0.37 → 0.0.38

package/dist/typescript/src/primitives/index.d.ts

@@ -14,4 +14,5 @@ export * from "./portal";
 export * from "./calendar";
 export * from "./tabs";
 export * from "./checkbox";
+export * from "./alert-dialog";
 //# sourceMappingURL=index.d.ts.map

package/dist/typescript/src/primitives/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@korsolutions/ui",
-  "version": "0.0.37",
+  "version": "0.0.38",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/components/alert-dialog/alert-dialog.tsx

@@ -0,0 +1,38 @@
+import { AlertDialogPrimitive } from "@/primitives";
+import type { PressableProps } from "react-native";
+import { AlertDialogVariants } from "./variants";
+
+interface AlertDialogProps {
+  trigger: React.ReactElement<PressableProps>;
+  title: string;
+  description: string;
+  actionLabel?: string;
+  cancelLabel?: string;
+  onAction?: () => void;
+  onCancel?: () => void;
+  variant?: keyof typeof AlertDialogVariants;
+}
+
+export function AlertDialog(props: AlertDialogProps) {
+  const { title, description, actionLabel = "Continue", cancelLabel = "Cancel", onAction, onCancel, variant = "default" } = props;
+
+  const useVariantStyles = AlertDialogVariants[variant];
+  const variantStyles = useVariantStyles();
+
+  return (
+    <AlertDialogPrimitive.Root styles={variantStyles}>
+      <AlertDialogPrimitive.Trigger>{props.trigger}</AlertDialogPrimitive.Trigger>
+      <AlertDialogPrimitive.Portal>
+        <AlertDialogPrimitive.Overlay />
+        <AlertDialogPrimitive.Content>
+          <AlertDialogPrimitive.Title>{title}</AlertDialogPrimitive.Title>
+          <AlertDialogPrimitive.Description>{description}</AlertDialogPrimitive.Description>
+          <AlertDialogPrimitive.Footer>
+            <AlertDialogPrimitive.Cancel onPress={onCancel}>{cancelLabel}</AlertDialogPrimitive.Cancel>
+            <AlertDialogPrimitive.Action onPress={onAction}>{actionLabel}</AlertDialogPrimitive.Action>
+          </AlertDialogPrimitive.Footer>
+        </AlertDialogPrimitive.Content>
+      </AlertDialogPrimitive.Portal>
+    </AlertDialogPrimitive.Root>
+  );
+}

package/src/components/alert-dialog/async-alert-dialog.tsx

@@ -0,0 +1,121 @@
+import { AlertDialogPrimitive } from "@/primitives";
+import React, { useEffect, useState } from "react";
+import { useAlertDialog } from "@/primitives/alert-dialog/context";
+import { AlertDialogVariants } from "./variants";
+
+interface AsyncAlertDialogProps {
+  title: string;
+  description: string;
+  actionLabel?: string;
+  cancelLabel?: string;
+  variant?: keyof typeof AlertDialogVariants;
+}
+
+interface AsyncAlertDialogResult {
+  confirmed: boolean;
+}
+
+interface AsyncAlertDialogInstance {
+  id: string;
+  resolve: (result: AsyncAlertDialogResult) => void;
+  props: AsyncAlertDialogProps;
+}
+
+// Global state
+const dialogQueue: AsyncAlertDialogInstance[] = [];
+let currentDialog: AsyncAlertDialogInstance | null = null;
+let setCurrentDialogFn: ((dialog: AsyncAlertDialogInstance | null) => void) | null = null;
+
+// Process next dialog in queue
+function processQueue() {
+  if (currentDialog || dialogQueue.length === 0) return;
+
+  currentDialog = dialogQueue.shift()!;
+  setCurrentDialogFn?.(currentDialog);
+}
+
+// Close current dialog
+function closeDialog(confirmed: boolean) {
+  if (!currentDialog) return;
+
+  currentDialog.resolve({ confirmed });
+  currentDialog = null;
+  setCurrentDialogFn?.(null);
+
+  // Process next in queue after a small delay
+  setTimeout(processQueue, 100);
+}
+
+// Inner component that has access to the dialog context
+function AsyncAlertDialogContent({ instance }: { instance: AsyncAlertDialogInstance }) {
+  const { title, description, actionLabel = "Continue", cancelLabel = "Cancel" } = instance.props;
+  const { setIsOpen } = useAlertDialog();
+
+  const handleAction = () => closeDialog(true);
+  const handleCancel = () => closeDialog(false);
+
+  // Automatically open the dialog when mounted
+  useEffect(() => {
+    setIsOpen(true);
+  }, [setIsOpen]);
+
+  return (
+    <AlertDialogPrimitive.Portal>
+      <AlertDialogPrimitive.Overlay onPress={handleCancel} />
+      <AlertDialogPrimitive.Content>
+        <AlertDialogPrimitive.Title>{title}</AlertDialogPrimitive.Title>
+        <AlertDialogPrimitive.Description>{description}</AlertDialogPrimitive.Description>
+        <AlertDialogPrimitive.Footer>
+          <AlertDialogPrimitive.Cancel onPress={handleCancel}>{cancelLabel}</AlertDialogPrimitive.Cancel>
+          <AlertDialogPrimitive.Action onPress={handleAction}>{actionLabel}</AlertDialogPrimitive.Action>
+        </AlertDialogPrimitive.Footer>
+      </AlertDialogPrimitive.Content>
+    </AlertDialogPrimitive.Portal>
+  );
+}
+
+// Component that renders a single dialog instance
+function AsyncAlertDialogInstance({ instance }: { instance: AsyncAlertDialogInstance }) {
+  const { variant = "default" } = instance.props;
+
+  const useVariantStyles = AlertDialogVariants[variant];
+  const variantStyles = useVariantStyles();
+
+  return (
+    <AlertDialogPrimitive.Root styles={variantStyles}>
+      <AsyncAlertDialogContent instance={instance} />
+    </AlertDialogPrimitive.Root>
+  );
+}
+
+export function AsyncAlertDialogManager() {
+  const [dialog, setDialog] = useState<AsyncAlertDialogInstance | null>(null);
+
+  useEffect(() => {
+    setCurrentDialogFn = setDialog;
+    return () => {
+      setCurrentDialogFn = null;
+    };
+  }, []);
+
+  if (!dialog) return null;
+
+  return <AsyncAlertDialogInstance instance={dialog} />;
+}
+
+function show(props: AsyncAlertDialogProps): Promise<AsyncAlertDialogResult> {
+  return new Promise((resolve) => {
+    const instance: AsyncAlertDialogInstance = {
+      id: Date.now().toString(),
+      props,
+      resolve,
+    };
+
+    dialogQueue.push(instance);
+    processQueue();
+  });
+}
+
+export const AsyncAlertDialog = {
+  show,
+};

package/src/components/alert-dialog/index.ts

@@ -0,0 +1,3 @@
+export { AlertDialog } from "./alert-dialog";
+export { AlertDialogVariants } from "./variants";
+export { AsyncAlertDialog, AsyncAlertDialogManager } from "./async-alert-dialog";

package/src/components/alert-dialog/variants/default.tsx

@@ -0,0 +1,82 @@
+import { type AlertDialogStyles } from "@/primitives";
+import { useThemedStyles } from "@/utils/use-themed-styles";
+
+export const useAlertDialogVariantDefault = (): AlertDialogStyles => {
+  return useThemedStyles(
+    ({ colors, radius, fontFamily, fontSize }): AlertDialogStyles => ({
+      overlay: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "rgba(0, 0, 0, 0.5)",
+        justifyContent: "center",
+        alignItems: "center",
+      },
+      content: {
+        backgroundColor: colors.background,
+        borderRadius: radius,
+        padding: 24,
+        maxWidth: 400,
+        width: "90%",
+        shadowColor: "#000",
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.25,
+        shadowRadius: 8,
+        elevation: 5,
+        position: "absolute",
+        top: "50%",
+        left: "50%",
+        transform: [{ translateX: "-50%" }, { translateY: "-50%" }],
+        borderWidth: 1,
+        borderColor: colors.border,
+      },
+      title: {
+        fontSize: fontSize * 1.25,
+        fontWeight: "600",
+        color: colors.foreground,
+        fontFamily,
+        marginBottom: 8,
+      },
+      description: {
+        fontSize,
+        color: colors.mutedForeground,
+        fontFamily,
+        lineHeight: fontSize * 1.5,
+      },
+      footer: {
+        flexDirection: "row",
+        justifyContent: "flex-end",
+        gap: 12,
+        marginTop: 24,
+      },
+      cancel: {
+        paddingVertical: 10,
+        paddingHorizontal: 16,
+        borderRadius: radius,
+        borderWidth: 1,
+        borderColor: colors.border,
+        backgroundColor: colors.background,
+      },
+      cancelText: {
+        color: colors.foreground,
+        fontSize,
+        fontWeight: "500",
+        fontFamily,
+      },
+      action: {
+        paddingVertical: 10,
+        paddingHorizontal: 16,
+        borderRadius: radius,
+        backgroundColor: colors.primary,
+      },
+      actionText: {
+        color: colors.primaryForeground,
+        fontSize,
+        fontWeight: "500",
+        fontFamily,
+      },
+    })
+  );
+};

package/src/components/alert-dialog/variants/index.ts

@@ -0,0 +1,5 @@
+import { useAlertDialogVariantDefault } from "./default";
+
+export const AlertDialogVariants = {
+  default: useAlertDialogVariantDefault,
+};

package/src/components/index.ts

@@ -15,3 +15,4 @@ export * from "./popover/popover";
 export * from "./calendar/calendar";
 export * from "./tabs";
 export * from "./checkbox";
+export * from "./alert-dialog";

package/src/index.tsx

@@ -1,4 +1,5 @@
 import { ThemeProvider } from "@/themes";
+import { AsyncAlertDialogManager } from "./components/alert-dialog/async-alert-dialog";
 import { ToastContainer } from "./components/toast/toast-manager";
 import { PortalHost } from "./primitives/portal";
 import { type PortalHostProps } from "./primitives/portal/portal.constants";
@@ -15,6 +16,7 @@ export const UniversalUIProvider = ({ children, portalContainer }: ProviderProps
       <ToastContainer />
       {children}
       <PortalHost container={portalContainer} />
+      <AsyncAlertDialogManager />
     </ThemeProvider>
   );
 };

package/src/primitives/alert-dialog/alert-dialog-action.tsx

@@ -0,0 +1,27 @@
+import React from "react";
+import { Pressable, Text, type PressableProps, type StyleProp, type ViewStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveActionProps extends PressableProps {
+  children: React.ReactNode;
+  style?: StyleProp<ViewStyle>;
+}
+
+export function AlertDialogAction(props: AlertDialogPrimitiveActionProps) {
+  const { children, style, onPress, ...pressableProps } = props;
+  const { styles, setIsOpen } = useAlertDialog();
+
+  const handlePress: PressableProps["onPress"] = (event) => {
+    onPress?.(event);
+    setIsOpen(false);
+  };
+
+  const calculatedStyle = [styles?.action, style];
+  const textStyle = styles?.actionText;
+
+  return (
+    <Pressable {...pressableProps} style={calculatedStyle} onPress={handlePress}>
+      <Text style={textStyle}>{children}</Text>
+    </Pressable>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-cancel.tsx

@@ -0,0 +1,27 @@
+import React from "react";
+import { Pressable, Text, type PressableProps, type StyleProp, type ViewStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveCancelProps extends PressableProps {
+  children: React.ReactNode;
+  style?: StyleProp<ViewStyle>;
+}
+
+export function AlertDialogCancel(props: AlertDialogPrimitiveCancelProps) {
+  const { children, style, onPress, ...pressableProps } = props;
+  const { styles, setIsOpen } = useAlertDialog();
+
+  const handlePress: PressableProps["onPress"] = (event) => {
+    onPress?.(event);
+    setIsOpen(false);
+  };
+
+  const calculatedStyle = [styles?.cancel, style];
+  const textStyle = styles?.cancelText;
+
+  return (
+    <Pressable {...pressableProps} style={calculatedStyle} onPress={handlePress}>
+      <Text style={textStyle}>{children}</Text>
+    </Pressable>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-content.tsx

@@ -0,0 +1,21 @@
+import React from "react";
+import { View, type StyleProp, type ViewProps, type ViewStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveContentProps extends ViewProps {
+  children: React.ReactNode;
+  style?: StyleProp<ViewStyle>;
+}
+
+export function AlertDialogContent(props: AlertDialogPrimitiveContentProps) {
+  const { children, style, ...viewProps } = props;
+  const { styles } = useAlertDialog();
+
+  const calculatedStyle = [styles?.content, style];
+
+  return (
+    <View {...viewProps} style={calculatedStyle}>
+      {children}
+    </View>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-description.tsx

@@ -0,0 +1,21 @@
+import React from "react";
+import { Text, type StyleProp, type TextProps, type TextStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveDescriptionProps extends TextProps {
+  children: React.ReactNode;
+  style?: StyleProp<TextStyle>;
+}
+
+export function AlertDialogDescription(props: AlertDialogPrimitiveDescriptionProps) {
+  const { children, style, ...textProps } = props;
+  const { styles } = useAlertDialog();
+
+  const calculatedStyle = [styles?.description, style];
+
+  return (
+    <Text {...textProps} style={calculatedStyle}>
+      {children}
+    </Text>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-footer.tsx

@@ -0,0 +1,21 @@
+import React from "react";
+import { View, type StyleProp, type ViewProps, type ViewStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveFooterProps extends ViewProps {
+  children: React.ReactNode;
+  style?: StyleProp<ViewStyle>;
+}
+
+export function AlertDialogFooter(props: AlertDialogPrimitiveFooterProps) {
+  const { children, style, ...viewProps } = props;
+  const { styles } = useAlertDialog();
+
+  const calculatedStyle = [styles?.footer, style];
+
+  return (
+    <View {...viewProps} style={calculatedStyle}>
+      {children}
+    </View>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-overlay.tsx

@@ -0,0 +1,25 @@
+import React from "react";
+import { Pressable, type PressableProps, type StyleProp, type ViewStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveOverlayProps extends PressableProps {
+  style?: StyleProp<ViewStyle>;
+}
+
+export function AlertDialogOverlay(props: AlertDialogPrimitiveOverlayProps) {
+  const { style, ...pressableProps } = props;
+  const { styles, setIsOpen } = useAlertDialog();
+
+  const calculatedStyle = [styles?.overlay, style];
+
+  return (
+    <Pressable
+      {...pressableProps}
+      style={calculatedStyle}
+      onPress={() => setIsOpen(false)}
+      accessible={true}
+      accessibilityRole="button"
+      accessibilityLabel="Close alert dialog"
+    />
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-portal.tsx

@@ -0,0 +1,20 @@
+import React from "react";
+import { Portal } from "../portal";
+import { AlertDialogPrimitiveContext, useAlertDialog } from "./context";
+
+interface AlertDialogPortalProps {
+  children: React.ReactNode;
+}
+
+export function AlertDialogPortal(props: AlertDialogPortalProps) {
+  const alertDialog = useAlertDialog();
+
+  if (!alertDialog.isOpen) {
+    return null;
+  }
+  return (
+    <Portal name="alert-dialog-content">
+      <AlertDialogPrimitiveContext.Provider value={alertDialog}>{props.children}</AlertDialogPrimitiveContext.Provider>
+    </Portal>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-root.tsx

@@ -0,0 +1,25 @@
+import React, { useMemo, useState } from "react";
+import { AlertDialogPrimitiveContext } from "./context";
+import type { AlertDialogStyles } from "./types";
+
+export interface AlertDialogPrimitiveRootProps {
+  children: React.ReactNode;
+
+  styles?: AlertDialogStyles;
+}
+
+export function AlertDialogRoot(props: AlertDialogPrimitiveRootProps) {
+  const { children, styles } = props;
+  const [isOpen, setIsOpen] = useState(false);
+
+  const contextValue = useMemo(
+    () => ({
+      isOpen,
+      setIsOpen,
+      styles,
+    }),
+    [isOpen, styles]
+  );
+
+  return <AlertDialogPrimitiveContext.Provider value={contextValue}>{children}</AlertDialogPrimitiveContext.Provider>;
+}

package/src/primitives/alert-dialog/alert-dialog-title.tsx

@@ -0,0 +1,21 @@
+import React from "react";
+import { Text, type StyleProp, type TextProps, type TextStyle } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveTitleProps extends TextProps {
+  children: React.ReactNode;
+  style?: StyleProp<TextStyle>;
+}
+
+export function AlertDialogTitle(props: AlertDialogPrimitiveTitleProps) {
+  const { children, style, ...textProps } = props;
+  const { styles } = useAlertDialog();
+
+  const calculatedStyle = [styles?.title, style];
+
+  return (
+    <Text {...textProps} style={calculatedStyle}>
+      {children}
+    </Text>
+  );
+}

package/src/primitives/alert-dialog/alert-dialog-trigger.tsx

@@ -0,0 +1,27 @@
+import type { ViewRef } from "@/types/element.types";
+import React from "react";
+import { type PressableProps } from "react-native";
+import { useAlertDialog } from "./context";
+
+export interface AlertDialogPrimitiveTriggerProps extends PressableProps {
+  children: React.ReactElement<React.RefAttributes<ViewRef> & PressableProps>;
+}
+
+export function AlertDialogTrigger(props: AlertDialogPrimitiveTriggerProps) {
+  const { onPress } = props;
+  const { isOpen, setIsOpen } = useAlertDialog();
+
+  const handlePress: PressableProps["onPress"] = (event) => {
+    onPress?.(event);
+    setIsOpen(true);
+  };
+
+  return React.cloneElement(props.children, {
+    onPress: handlePress,
+    role: "button",
+    accessible: true,
+    accessibilityRole: "button",
+    accessibilityState: { expanded: isOpen },
+    ...props.children.props,
+  });
+}

package/src/primitives/alert-dialog/context.ts

@@ -0,0 +1,18 @@
+import React, { createContext, useContext, type Dispatch } from "react";
+import type { AlertDialogStyles } from "./types";
+
+export interface AlertDialogPrimitiveContextValue {
+  isOpen: boolean;
+  setIsOpen: Dispatch<React.SetStateAction<boolean>>;
+  styles?: AlertDialogStyles;
+}
+
+export const AlertDialogPrimitiveContext = createContext<AlertDialogPrimitiveContextValue | null>(null);
+
+export const useAlertDialog = () => {
+  const context = useContext(AlertDialogPrimitiveContext);
+  if (!context) {
+    throw new Error("AlertDialog compound components must be used within AlertDialogPrimitive.Root");
+  }
+  return context;
+};

package/src/primitives/alert-dialog/index.ts

@@ -0,0 +1,34 @@
+import { AlertDialogAction } from "./alert-dialog-action";
+import { AlertDialogCancel } from "./alert-dialog-cancel";
+import { AlertDialogContent } from "./alert-dialog-content";
+import { AlertDialogDescription } from "./alert-dialog-description";
+import { AlertDialogFooter } from "./alert-dialog-footer";
+import { AlertDialogOverlay } from "./alert-dialog-overlay";
+import { AlertDialogPortal } from "./alert-dialog-portal";
+import { AlertDialogRoot } from "./alert-dialog-root";
+import { AlertDialogTitle } from "./alert-dialog-title";
+import { AlertDialogTrigger } from "./alert-dialog-trigger";
+
+export const AlertDialogPrimitive = {
+  Root: AlertDialogRoot,
+  Trigger: AlertDialogTrigger,
+  Portal: AlertDialogPortal,
+  Overlay: AlertDialogOverlay,
+  Content: AlertDialogContent,
+  Title: AlertDialogTitle,
+  Description: AlertDialogDescription,
+  Footer: AlertDialogFooter,
+  Action: AlertDialogAction,
+  Cancel: AlertDialogCancel,
+};
+
+export type { AlertDialogPrimitiveActionProps } from "./alert-dialog-action";
+export type { AlertDialogPrimitiveCancelProps } from "./alert-dialog-cancel";
+export type { AlertDialogPrimitiveContentProps } from "./alert-dialog-content";
+export type { AlertDialogPrimitiveDescriptionProps } from "./alert-dialog-description";
+export type { AlertDialogPrimitiveFooterProps } from "./alert-dialog-footer";
+export type { AlertDialogPrimitiveOverlayProps } from "./alert-dialog-overlay";
+export type { AlertDialogPrimitiveRootProps } from "./alert-dialog-root";
+export type { AlertDialogPrimitiveTitleProps } from "./alert-dialog-title";
+export type { AlertDialogPrimitiveTriggerProps } from "./alert-dialog-trigger";
+export * from "./types";

package/src/primitives/alert-dialog/types.ts

@@ -0,0 +1,13 @@
+import type { StyleProp, TextStyle, ViewStyle } from "react-native";
+
+export interface AlertDialogStyles {
+  overlay?: StyleProp<ViewStyle>;
+  content?: StyleProp<ViewStyle>;
+  title?: StyleProp<TextStyle>;
+  description?: StyleProp<TextStyle>;
+  footer?: StyleProp<ViewStyle>;
+  action?: StyleProp<ViewStyle>;
+  actionText?: StyleProp<TextStyle>;
+  cancel?: StyleProp<ViewStyle>;
+  cancelText?: StyleProp<TextStyle>;
+}

package/src/primitives/index.ts

@@ -14,3 +14,4 @@ export * from "./portal";
 export * from "./calendar";
 export * from "./tabs";
 export * from "./checkbox";
+export * from "./alert-dialog";

package/src/primitives/popover/popover-portal.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import { Portal } from "../portal";
-import { usePopover, PopoverContext } from "./context";
+import { PopoverContext, usePopover } from "./context";
 
 export interface PopoverPortalProps {
   children?: React.ReactNode;