tembro 3.0.0 → 3.1.5

package/packages/cli/vendor/src/components/modern/image-cropper.tsx

@@ -0,0 +1,226 @@
+"use client"
+
+import * as React from "react"
+import Cropper, { type Area, type Point } from "react-easy-crop"
+import { RotateCwIcon, ZoomInIcon } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+function degreesToRadians(degrees: number) {
+  return (degrees * Math.PI) / 180
+}
+
+function getRotatedSize(width: number, height: number, rotation: number) {
+  const radians = degreesToRadians(rotation)
+  return {
+    width: Math.abs(Math.cos(radians) * width) + Math.abs(Math.sin(radians) * height),
+    height: Math.abs(Math.sin(radians) * width) + Math.abs(Math.cos(radians) * height),
+  }
+}
+
+function loadImage(src: string, crossOrigin?: string) {
+  return new Promise<HTMLImageElement>((resolve, reject) => {
+    const image = new Image()
+    if (crossOrigin) image.crossOrigin = crossOrigin
+    image.onload = () => resolve(image)
+    image.onerror = () => reject(new Error("Crop source image could not be loaded"))
+    image.src = src
+  })
+}
+
+export async function createCroppedImageBlob({
+  src,
+  crop,
+  rotation = 0,
+  type = "image/png",
+  quality = 0.92,
+  crossOrigin = "anonymous",
+}: {
+  src: string
+  crop: Area
+  rotation?: number
+  type?: string
+  quality?: number
+  crossOrigin?: string
+}) {
+  const image = await loadImage(src, crossOrigin)
+  const rotatedSize = getRotatedSize(image.naturalWidth, image.naturalHeight, rotation)
+  const sourceCanvas = document.createElement("canvas")
+  sourceCanvas.width = Math.ceil(rotatedSize.width)
+  sourceCanvas.height = Math.ceil(rotatedSize.height)
+  const sourceContext = sourceCanvas.getContext("2d")
+  if (!sourceContext) throw new Error("Canvas 2D context is unavailable")
+
+  sourceContext.translate(sourceCanvas.width / 2, sourceCanvas.height / 2)
+  sourceContext.rotate(degreesToRadians(rotation))
+  sourceContext.translate(-image.naturalWidth / 2, -image.naturalHeight / 2)
+  sourceContext.drawImage(image, 0, 0)
+
+  const outputCanvas = document.createElement("canvas")
+  outputCanvas.width = Math.max(1, Math.round(crop.width))
+  outputCanvas.height = Math.max(1, Math.round(crop.height))
+  const outputContext = outputCanvas.getContext("2d")
+  if (!outputContext) throw new Error("Canvas 2D context is unavailable")
+  outputContext.drawImage(
+    sourceCanvas,
+    Math.round(crop.x),
+    Math.round(crop.y),
+    Math.round(crop.width),
+    Math.round(crop.height),
+    0,
+    0,
+    outputCanvas.width,
+    outputCanvas.height
+  )
+
+  return new Promise<Blob>((resolve, reject) => {
+    outputCanvas.toBlob(
+      (blob) => (blob ? resolve(blob) : reject(new Error("Cropped image could not be encoded"))),
+      type,
+      quality
+    )
+  })
+}
+
+export type ImageCropperProps = Omit<React.ComponentProps<"div">, "onChange"> & {
+  src: string
+  alt?: string
+  crop?: Point
+  defaultCrop?: Point
+  onCropChange?: (crop: Point) => void
+  zoom?: number
+  defaultZoom?: number
+  onZoomChange?: (zoom: number) => void
+  rotation?: number
+  defaultRotation?: number
+  onRotationChange?: (rotation: number) => void
+  onCropComplete?: (area: Area, areaPixels: Area) => void
+  aspect?: number
+  cropShape?: "rect" | "round"
+  objectFit?: "contain" | "cover" | "horizontal-cover" | "vertical-cover"
+  minZoom?: number
+  maxZoom?: number
+  zoomStep?: number
+  showGrid?: boolean
+  disabled?: boolean
+  labels?: {
+    cropper?: string
+    zoom?: string
+    rotation?: string
+  }
+}
+
+function ImageCropper({
+  src,
+  alt = "Image crop preview",
+  crop,
+  defaultCrop = { x: 0, y: 0 },
+  onCropChange,
+  zoom,
+  defaultZoom = 1,
+  onZoomChange,
+  rotation,
+  defaultRotation = 0,
+  onRotationChange,
+  onCropComplete,
+  aspect = 1,
+  cropShape = "rect",
+  objectFit = "contain",
+  minZoom = 1,
+  maxZoom = 3,
+  zoomStep = 0.1,
+  showGrid = true,
+  disabled = false,
+  labels,
+  className,
+  ...props
+}: ImageCropperProps) {
+  const [internalCrop, setInternalCrop] = React.useState(defaultCrop)
+  const [internalZoom, setInternalZoom] = React.useState(defaultZoom)
+  const [internalRotation, setInternalRotation] = React.useState(defaultRotation)
+  const currentCrop = crop ?? internalCrop
+  const currentZoom = zoom ?? internalZoom
+  const currentRotation = rotation ?? internalRotation
+
+  return (
+    <div data-slot="image-cropper" data-disabled={disabled || undefined} className={cn("grid gap-3 data-[disabled]:opacity-60", className)} {...props}>
+      <div
+        role="img"
+        aria-label={labels?.cropper ?? alt}
+        className={cn("relative min-h-64 overflow-hidden rounded-md bg-black", disabled && "pointer-events-none")}
+        style={{ aspectRatio: aspect }}
+      >
+        <Cropper
+          image={src}
+          crop={currentCrop}
+          zoom={currentZoom}
+          rotation={currentRotation}
+          aspect={aspect}
+          cropShape={cropShape}
+          objectFit={objectFit}
+          minZoom={minZoom}
+          maxZoom={maxZoom}
+          zoomSpeed={zoomStep}
+          showGrid={showGrid}
+          onCropChange={(nextCrop) => {
+            if (crop === undefined) setInternalCrop(nextCrop)
+            onCropChange?.(nextCrop)
+          }}
+          onZoomChange={(nextZoom) => {
+            if (zoom === undefined) setInternalZoom(nextZoom)
+            onZoomChange?.(nextZoom)
+          }}
+          onRotationChange={(nextRotation) => {
+            if (rotation === undefined) setInternalRotation(nextRotation)
+            onRotationChange?.(nextRotation)
+          }}
+          onCropComplete={onCropComplete}
+        />
+      </div>
+      <div className="grid gap-2 sm:grid-cols-2">
+        <label className="grid grid-cols-[auto_1fr_auto] items-center gap-2 text-xs text-muted-foreground">
+          <ZoomInIcon className="size-4" aria-hidden="true" />
+          <span className="sr-only">{labels?.zoom ?? "Zoom"}</span>
+          <input
+            type="range"
+            min={minZoom}
+            max={maxZoom}
+            step={zoomStep}
+            value={currentZoom}
+            disabled={disabled}
+            aria-label={labels?.zoom ?? "Zoom"}
+            className="w-full accent-foreground"
+            onChange={(event) => {
+              const nextZoom = Number(event.target.value)
+              if (zoom === undefined) setInternalZoom(nextZoom)
+              onZoomChange?.(nextZoom)
+            }}
+          />
+          <span className="w-9 text-right tabular-nums">{currentZoom.toFixed(1)}x</span>
+        </label>
+        <label className="grid grid-cols-[auto_1fr_auto] items-center gap-2 text-xs text-muted-foreground">
+          <RotateCwIcon className="size-4" aria-hidden="true" />
+          <span className="sr-only">{labels?.rotation ?? "Rotation"}</span>
+          <input
+            type="range"
+            min="-180"
+            max="180"
+            step="1"
+            value={currentRotation}
+            disabled={disabled}
+            aria-label={labels?.rotation ?? "Rotation"}
+            className="w-full accent-foreground"
+            onChange={(event) => {
+              const nextRotation = Number(event.target.value)
+              if (rotation === undefined) setInternalRotation(nextRotation)
+              onRotationChange?.(nextRotation)
+            }}
+          />
+          <span className="w-10 text-right tabular-nums">{Math.round(currentRotation)}°</span>
+        </label>
+      </div>
+    </div>
+  )
+}
+
+export { ImageCropper }

package/packages/cli/vendor/src/components/modern/index.ts

@@ -1,11 +1,5 @@
-export * from "../display/carousel"
-export * from "../display/qr-code"
-export * from "../display/tag"
-export * from "../display/typography"
 export * from "./calendar-scheduler"
 export * from "./dual-list-picker"
-export * from "./menubar"
-export * from "./navigation-menu"
-export * from "./resizable-panel"
-export * from "./rich-text-editor"
-export * from "./tour"
+export * from "./resizable-panel"
+export * from "./rich-text-editor"
+export * from "./image-cropper"

package/packages/cli/vendor/src/components/modern/rich-text-editor.tsx

@@ -1,49 +1,199 @@
-"use client"
-
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-export type RichTextEditorProps = Omit<React.ComponentProps<"div">, "onChange"> & {
+"use client"
+
+import * as React from "react"
+import { EditorContent, useEditor, type Editor } from "@tiptap/react"
+import StarterKit from "@tiptap/starter-kit"
+import Link from "@tiptap/extension-link"
+import Placeholder from "@tiptap/extension-placeholder"
+import {
+  BoldIcon,
+  CodeIcon,
+  Heading2Icon,
+  ItalicIcon,
+  LinkIcon,
+  ListIcon,
+  ListOrderedIcon,
+  QuoteIcon,
+  Redo2Icon,
+  StrikethroughIcon,
+  Undo2Icon,
+  UnlinkIcon,
+} from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+export type RichTextEditorProps = Omit<React.ComponentProps<"div">, "defaultValue" | "onChange"> & {
   value?: string
+  defaultValue?: string
   onValueChange?: (value: string) => void
+  output?: "text" | "html"
   placeholder?: string
-  output?: "html" | "text"
+  editable?: boolean
+  autoFocus?: boolean
+  minHeight?: number
+  onLinkRequest?: (currentHref?: string) => string | null | undefined
+  labels?: {
+    editor?: string
+    toolbar?: string
+  }
+}
+
+type ToolbarAction = {
+  label: string
+  icon: React.ComponentType<{ className?: string }>
+  active?: boolean
   disabled?: boolean
+  run: () => void
+}
+
+function escapeHtml(value: string) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
 }
 
-function RichTextEditor({ value, onValueChange, placeholder = "Write something...", output = "html", disabled = false, className, ...props }: RichTextEditorProps) {
-  const ref = React.useRef<HTMLDivElement | null>(null)
-
-  React.useEffect(() => {
-    if (ref.current && value !== undefined && ref.current.innerHTML !== value) {
-      ref.current.innerHTML = value
-    }
-  }, [value])
-
-  return (
-    <div data-slot="rich-text-editor" data-disabled={disabled || undefined} className={cn("grid gap-2 rounded-lg border bg-background p-2", disabled && "opacity-60", className)} {...props}>
-      <div className="flex flex-wrap gap-1 border-b pb-2">
-        {[
-          ["bold", "B"],
-          ["italic", "I"],
-          ["underline", "U"],
-        ].map(([command, label]) => (
-          <button key={command} type="button" disabled={disabled} className="rounded border px-2 py-1 text-xs font-medium disabled:opacity-50" onClick={() => document.execCommand(command)}>
-            {label}
+function contentForEditor(value: string, output: "text" | "html") {
+  return output === "html" ? value : `<p>${escapeHtml(value)}</p>`
+}
+
+function EditorToolbar({ editor, onLinkRequest, label }: { editor: Editor; onLinkRequest?: RichTextEditorProps["onLinkRequest"]; label: string }) {
+  const linkHref = editor.getAttributes("link").href as string | undefined
+  const actions: ToolbarAction[] = [
+    { label: "Undo", icon: Undo2Icon, disabled: !editor.can().undo(), run: () => editor.chain().focus().undo().run() },
+    { label: "Redo", icon: Redo2Icon, disabled: !editor.can().redo(), run: () => editor.chain().focus().redo().run() },
+    { label: "Bold", icon: BoldIcon, active: editor.isActive("bold"), run: () => editor.chain().focus().toggleBold().run() },
+    { label: "Italic", icon: ItalicIcon, active: editor.isActive("italic"), run: () => editor.chain().focus().toggleItalic().run() },
+    { label: "Strike", icon: StrikethroughIcon, active: editor.isActive("strike"), run: () => editor.chain().focus().toggleStrike().run() },
+    { label: "Inline code", icon: CodeIcon, active: editor.isActive("code"), run: () => editor.chain().focus().toggleCode().run() },
+    { label: "Heading", icon: Heading2Icon, active: editor.isActive("heading", { level: 2 }), run: () => editor.chain().focus().toggleHeading({ level: 2 }).run() },
+    { label: "Bullet list", icon: ListIcon, active: editor.isActive("bulletList"), run: () => editor.chain().focus().toggleBulletList().run() },
+    { label: "Ordered list", icon: ListOrderedIcon, active: editor.isActive("orderedList"), run: () => editor.chain().focus().toggleOrderedList().run() },
+    { label: "Blockquote", icon: QuoteIcon, active: editor.isActive("blockquote"), run: () => editor.chain().focus().toggleBlockquote().run() },
+  ]
+
+  if (onLinkRequest) {
+    actions.push({
+      label: "Set link",
+      icon: LinkIcon,
+      active: editor.isActive("link"),
+      run: () => {
+        const href = onLinkRequest(linkHref)
+        if (href === null || href === undefined) return
+        if (!href.trim()) editor.chain().focus().unsetLink().run()
+        else editor.chain().focus().extendMarkRange("link").setLink({ href: href.trim() }).run()
+      },
+    })
+  }
+
+  if (editor.isActive("link")) {
+    actions.push({ label: "Remove link", icon: UnlinkIcon, run: () => editor.chain().focus().unsetLink().run() })
+  }
+
+  return (
+    <div role="toolbar" aria-label={label} className="flex flex-wrap gap-1 border-b p-1.5">
+      {actions.map((action) => {
+        const Icon = action.icon
+        return (
+          <button
+            key={action.label}
+            type="button"
+            title={action.label}
+            aria-label={action.label}
+            aria-pressed={action.active || undefined}
+            disabled={action.disabled}
+            className="inline-flex size-8 items-center justify-center rounded-md text-muted-foreground outline-none hover:bg-accent hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring aria-pressed:bg-accent aria-pressed:text-foreground disabled:pointer-events-none disabled:opacity-40"
+            onClick={action.run}
+          >
+            <Icon className="size-4" />
           </button>
-        ))}
-      </div>
-      <div
-        ref={ref}
-        contentEditable={!disabled}
-        aria-disabled={disabled || undefined}
-        data-placeholder={placeholder}
-        className="min-h-32 rounded-md p-2 text-sm outline-none empty:before:text-muted-foreground empty:before:content-[attr(data-placeholder)]"
-        onInput={(event) => onValueChange?.(output === "text" ? event.currentTarget.textContent ?? "" : event.currentTarget.innerHTML)}
+        )
+      })}
+    </div>
+  )
+}
+
+function MountedRichTextEditor({
+  value,
+  defaultValue = "",
+  onValueChange,
+  output = "html",
+  placeholder = "Start typing...",
+  editable = true,
+  autoFocus = false,
+  minHeight = 144,
+  onLinkRequest,
+  labels,
+  className,
+  ...props
+}: RichTextEditorProps) {
+  const initialContent = value ?? defaultValue
+  const editor = useEditor({
+    immediatelyRender: true,
+    autofocus: autoFocus,
+    editable,
+    editorProps: {
+      attributes: {
+        "aria-label": labels?.editor ?? "Rich text editor",
+        role: "textbox",
+      },
+    },
+    content: contentForEditor(initialContent, output),
+    extensions: [
+      StarterKit.configure({ link: false }),
+      Link.configure({ openOnClick: false, autolink: true, defaultProtocol: "https" }),
+      Placeholder.configure({ placeholder }),
+    ],
+    onUpdate: ({ editor: nextEditor }) => {
+      onValueChange?.(output === "html" ? nextEditor.getHTML() : nextEditor.getText())
+    },
+  })
+
+  React.useEffect(() => {
+    if (!editor || value === undefined) return
+    const currentValue = output === "html" ? editor.getHTML() : editor.getText()
+    if (currentValue !== value) editor.commands.setContent(contentForEditor(value, output), { emitUpdate: false })
+  }, [editor, output, value])
+
+  React.useEffect(() => {
+    editor?.setEditable(editable)
+  }, [editable, editor])
+
+  return (
+    <div
+      data-slot="rich-text-editor"
+      data-disabled={!editable || undefined}
+      className={cn("overflow-hidden rounded-md border bg-background shadow-sm focus-within:ring-2 focus-within:ring-ring data-[disabled]:opacity-60", className)}
+      {...props}
+    >
+      {editor && editable ? <EditorToolbar editor={editor} onLinkRequest={onLinkRequest} label={labels?.toolbar ?? "Text formatting"} /> : null}
+      <EditorContent
+        editor={editor}
+        aria-label={labels?.editor ?? "Rich text editor"}
+        className="[&_.tiptap]:px-3 [&_.tiptap]:py-2.5 [&_.tiptap]:outline-none [&_.tiptap_a]:text-primary [&_.tiptap_a]:underline [&_.tiptap_blockquote]:border-l-2 [&_.tiptap_blockquote]:pl-3 [&_.tiptap_h2]:text-lg [&_.tiptap_h2]:font-semibold [&_.tiptap_ol]:list-decimal [&_.tiptap_ol]:pl-6 [&_.tiptap_p.is-editor-empty:first-child:before]:pointer-events-none [&_.tiptap_p.is-editor-empty:first-child:before]:float-left [&_.tiptap_p.is-editor-empty:first-child:before]:h-0 [&_.tiptap_p.is-editor-empty:first-child:before]:text-muted-foreground [&_.tiptap_p.is-editor-empty:first-child:before]:content-[attr(data-placeholder)] [&_.tiptap_ul]:list-disc [&_.tiptap_ul]:pl-6"
+        style={{ minHeight }}
       />
     </div>
   )
 }
-
-export { RichTextEditor }
+
+function RichTextEditor(props: RichTextEditorProps) {
+  const [mounted, setMounted] = React.useState(false)
+
+  React.useEffect(() => {
+    setMounted(true)
+  }, [])
+
+  if (!mounted) {
+    return (
+      <div
+        data-slot="rich-text-editor"
+        data-state="loading"
+        className={cn("overflow-hidden rounded-md border bg-background shadow-sm", props.className)}
+        style={{ minHeight: props.minHeight ?? 144 }}
+        aria-busy="true"
+      />
+    )
+  }
+
+  return <MountedRichTextEditor {...props} />
+}
+
+export { EditorToolbar, RichTextEditor }

package/packages/cli/vendor/src/components/navigation/demo.tsx

@@ -2,7 +2,4 @@ import { component, createShowcaseDemoRegistry } from "@/showcase/create-demo"
 
 export const navigationShowcaseDemoRegistry = createShowcaseDemoRegistry([
   component("pagination", "Pagination", "navigation", "Controlled page navigation with edge buttons and active state."),
-  component("nav-tabs", "NavTabs", "navigation", "Navigation tabs for switching related document sections."),
-  component("page-tabs", "PageTabs", "navigation", "Top-level page tab strip for route-sized sections."),
-  component("stepper-tabs", "StepperTabs", "navigation", "Step-like tabs for setup and onboarding progress."),
 ])

package/packages/cli/vendor/src/components/navigation/index.ts

@@ -1,6 +1 @@
-export * from "./anchor-nav"
-export * from "./nav-tabs"
-export * from "./page-tabs"
 export * from "./pagination"
-export * from "./stepper-tabs"
-export * from "./command-bar"

package/packages/cli/vendor/src/components/overlay/confirm-dialog.tsx

@@ -1,15 +1,37 @@
 "use client"
 
-import * as React from "react"
-
-import { DialogActionButton, DialogActions } from "@/components/overlay/dialog-actions"
-import { ModalShell, type ModalShellProps } from "@/components/overlay/modal-shell"
-
-type ConfirmVariant = React.ComponentProps<typeof DialogActionButton>["variant"]
-
-type ConfirmDialogProps = Omit<ModalShellProps, "footer"> & {
-  cancelText?: React.ReactNode
-  confirmText?: React.ReactNode
+import * as React from "react"
+
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog"
+import { cn } from "@/lib/utils"
+
+type ConfirmVariant = React.ComponentProps<typeof Button>["variant"]
+type ConfirmDialogSize = "sm" | "md" | "lg" | "xl" | "full"
+
+type ConfirmDialogProps = {
+  open?: boolean
+  defaultOpen?: boolean
+  onOpenChange?: (open: boolean) => void
+  trigger?: React.ReactNode
+  title?: React.ReactNode
+  description?: React.ReactNode
+  children?: React.ReactNode
+  size?: ConfirmDialogSize
+  showCloseButton?: boolean
+  contentClassName?: string
+  headerClassName?: string
+  bodyClassName?: string
+  cancelText?: React.ReactNode
+  confirmText?: React.ReactNode
   confirmVariant?: ConfirmVariant
   confirmDisabled?: boolean
   cancelDisabled?: boolean
@@ -19,9 +41,26 @@ type ConfirmDialogProps = Omit<ModalShellProps, "footer"> & {
   onCancel?: () => void
   onConfirm?: () => void | Promise<void>
 }
-
-function ConfirmDialog({
-  cancelText = "Cancel",
+
+function renderConfirmDialogTrigger(trigger: React.ReactNode) {
+  if (!trigger) return null
+  if (React.isValidElement(trigger)) return <DialogTrigger render={trigger} />
+  return <DialogTrigger>{trigger}</DialogTrigger>
+}
+
+function ConfirmDialog({
+  open,
+  defaultOpen,
+  trigger,
+  title,
+  description,
+  children,
+  size = "md",
+  showCloseButton = true,
+  contentClassName,
+  headerClassName,
+  bodyClassName,
+  cancelText = "Cancel",
   confirmText = "Confirm",
   confirmVariant = "default",
   confirmDisabled = false,
@@ -32,7 +71,6 @@ function ConfirmDialog({
   onCancel,
   onConfirm,
   onOpenChange,
-  ...props
 }: ConfirmDialogProps) {
   const [pending, setPending] = React.useState(false)
   const resolvedLoading = isLoading || pending
@@ -69,34 +107,50 @@ function ConfirmDialog({
   }
 
   return (
-    <ModalShell
-      showCloseButton={!resolvedLoading}
-      onOpenChange={handleOpenChange}
-      footer={
-        <DialogActions>
-          <DialogActionButton
+    <Dialog open={open} defaultOpen={defaultOpen} onOpenChange={handleOpenChange}>
+      {renderConfirmDialogTrigger(trigger)}
+      <DialogContent
+        size={size}
+        showCloseButton={showCloseButton && !resolvedLoading}
+        className={contentClassName}
+      >
+        {(title || description) && (
+          <DialogHeader className={headerClassName}>
+            {title && <DialogTitle>{title}</DialogTitle>}
+            {description && <DialogDescription>{description}</DialogDescription>}
+          </DialogHeader>
+        )}
+
+        {children && (
+          <div data-slot="confirm-dialog-body" className={cn("min-w-0", bodyClassName)}>
+            {children}
+          </div>
+        )}
+
+        <DialogFooter>
+          <Button
             type="button"
             variant="outline"
             disabled={cancelDisabled || resolvedLoading}
             onClick={handleCancel}
           >
             {cancelText}
-          </DialogActionButton>
-          <DialogActionButton
+          </Button>
+          <Button
             type="button"
             variant={confirmVariant}
             disabled={confirmDisabled || resolvedLoading}
-            isLoading={resolvedLoading}
+            loading={resolvedLoading}
+            loadingLabel={typeof confirmText === "string" ? confirmText : "Loading"}
             onClick={() => void handleConfirm()}
           >
             {confirmText}
-          </DialogActionButton>
-        </DialogActions>
-      }
-      {...props}
-    />
-  )
-}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
 
 export { ConfirmDialog }
 export type { ConfirmDialogProps }

package/packages/cli/vendor/src/components/overlay/index.ts

@@ -1,6 +1,3 @@
 export * from "./alert-dialog"
 export * from "./confirm-dialog"
-export * from "./dialog-actions"
 export * from "./drawer"
-export * from "./modal-shell"
-export * from "./sheet-shell"