@alexgorbatchev/shadcn 0.0.0-stage → 0.0.16

package/dist/chunk-zpcxr2r4.js

@@ -0,0 +1,98 @@
+import {
+  cn2
+} from "./chunk-cp2m7y7v.js";
+import {
+  Progress2
+} from "./chunk-5j39rehg.js";
+import {
+  pct
+} from "./chunk-v8ks0cfq.js";
+import {
+  paper,
+  mono
+} from "./chunk-fgmcbtyt.js";
+
+// src/components/assistant-ui/elements/SubagentList.tsx
+import { CheckIcon, Loader2Icon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function SubagentList2({
+  agents,
+  completedCount,
+  progress,
+  showSummary,
+  summaryAgent,
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs("div", {
+    "data-testid": "SubagentList",
+    "data-slot": "subagent-list",
+    className: cn2(cn2("flex w-full max-w-xs flex-col gap-2"), className),
+    ...props,
+    children: [
+      agents.map((agent, index) => {
+        const done = index < completedCount;
+        const width = progress[index] ?? 0;
+        const percentage = pct(width, 100);
+        return /* @__PURE__ */ jsxs("div", {
+          className: cn2(paper, "flex flex-col gap-2 rounded-md px-3.5 py-2.5"),
+          children: [
+            /* @__PURE__ */ jsxs("div", {
+              className: "flex items-center gap-2",
+              children: [
+                done ? /* @__PURE__ */ jsx(CheckIcon, {
+                  "aria-hidden": "true",
+                  className: cn2("size-4")
+                }) : /* @__PURE__ */ jsx(Loader2Icon, {
+                  "aria-hidden": "true",
+                  className: cn2("size-4", "animate-spin motion-reduce:animate-none")
+                }),
+                /* @__PURE__ */ jsx("span", {
+                  className: "flex-1 truncate text-base",
+                  children: agent.name
+                }),
+                /* @__PURE__ */ jsx("span", {
+                  className: cn2(mono, "text-muted-foreground"),
+                  children: agent.model
+                })
+              ]
+            }),
+            /* @__PURE__ */ jsx(Progress2, {
+              "aria-label": `${agent.name} progress`,
+              value: percentage,
+              tone: done ? "success" : "muted"
+            })
+          ]
+        }, agent.name);
+      }),
+      showSummary && /* @__PURE__ */ jsxs("div", {
+        className: cn2(paper, "fade-in slide-in-from-bottom-2 animate-in flex flex-col gap-2 rounded-md px-3.5 py-2.5 duration-300"),
+        children: [
+          /* @__PURE__ */ jsxs("div", {
+            className: "flex items-center gap-2",
+            children: [
+              /* @__PURE__ */ jsx(Loader2Icon, {
+                "aria-hidden": "true",
+                className: cn2("size-4", "animate-spin motion-reduce:animate-none")
+              }),
+              /* @__PURE__ */ jsx("span", {
+                className: "flex-1 truncate text-base",
+                children: summaryAgent.name
+              }),
+              /* @__PURE__ */ jsx("span", {
+                className: cn2(mono, "text-muted-foreground"),
+                children: summaryAgent.model
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx(Progress2, {
+            "aria-label": `${summaryAgent.name} progress`,
+            value: null
+          })
+        ]
+      })
+    ]
+  });
+}
+
+export { SubagentList2 };

package/dist/chunk-zve48bc0.js

@@ -0,0 +1,88 @@
+import {
+  cn2
+} from "./chunk-cp2m7y7v.js";
+import {
+  Button2
+} from "./chunk-73rkr9ct.js";
+
+// src/components/assistant-ui/elements/ConnectionState.tsx
+import { CheckIcon, CloudOffIcon, Loader2Icon } from "lucide-react";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+function ConnectionState2({
+  phase,
+  attempt,
+  resumedTokens,
+  onRetry,
+  ...props
+}) {
+  if (phase === "online")
+    return null;
+  return /* @__PURE__ */ jsxs("div", {
+    ...props,
+    role: "status",
+    "data-testid": "ConnectionState",
+    "data-slot": "connection-state",
+    className: "flex w-full max-w-sm items-center gap-2 rounded-md border border-frame-edge bg-card p-2 text-sm text-card-foreground shadow-frame",
+    children: [
+      phase === "dropped" ? /* @__PURE__ */ jsxs(Fragment, {
+        children: [
+          /* @__PURE__ */ jsx(CloudOffIcon, {
+            "aria-hidden": "true",
+            className: cn2("size-4")
+          }),
+          /* @__PURE__ */ jsx("span", {
+            className: "min-w-0 flex-1",
+            children: "Connection lost. The run kept going on the server."
+          }),
+          /* @__PURE__ */ jsx(Button2, {
+            variant: "ghost",
+            onClick: onRetry,
+            disabled: !onRetry,
+            children: "Reconnect"
+          })
+        ]
+      }) : null,
+      phase === "reconnecting" ? /* @__PURE__ */ jsxs(Fragment, {
+        children: [
+          /* @__PURE__ */ jsx(Loader2Icon, {
+            "aria-hidden": "true",
+            className: cn2("size-4", "animate-spin motion-reduce:animate-none")
+          }),
+          /* @__PURE__ */ jsx("span", {
+            className: "min-w-0 flex-1",
+            children: "Reconnecting"
+          }),
+          attempt !== undefined ? /* @__PURE__ */ jsxs("span", {
+            className: "shrink-0 font-mono text-sm text-muted-foreground tabular-nums",
+            children: [
+              "attempt ",
+              attempt
+            ]
+          }) : null
+        ]
+      }) : null,
+      phase === "resumed" ? /* @__PURE__ */ jsxs(Fragment, {
+        children: [
+          /* @__PURE__ */ jsx(CheckIcon, {
+            "aria-hidden": "true",
+            className: cn2("size-4", "text-success")
+          }),
+          /* @__PURE__ */ jsx("span", {
+            className: "min-w-0 flex-1",
+            children: "Picked the stream back up."
+          }),
+          resumedTokens !== undefined ? /* @__PURE__ */ jsxs("span", {
+            className: "shrink-0 font-mono text-sm text-muted-foreground tabular-nums",
+            children: [
+              "+",
+              resumedTokens,
+              " tokens"
+            ]
+          }) : null
+        ]
+      }) : null
+    ]
+  });
+}
+
+export { ConnectionState2 };

package/dist/components/Accordion.d.ts

@@ -0,0 +1,12 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Accordion as AccordionPrimitive } from "@base-ui/react/accordion";
+type AccordionProps = AccordionPrimitive.Root.Props & IDensityProps;
+declare function Accordion({ density, className, ...props }: AccordionProps): ReactElement;
+type AccordionItemProps = AccordionPrimitive.Item.Props & IDensityProps;
+declare function AccordionItem({ density, className, ...props }: AccordionItemProps): ReactElement;
+type AccordionTriggerProps = AccordionPrimitive.Trigger.Props & IDensityProps;
+declare function AccordionTrigger({ density, className, children, ...props }: AccordionTriggerProps): ReactElement;
+type AccordionContentProps = AccordionPrimitive.Panel.Props & IDensityProps;
+declare function AccordionContent({ density, className, children, ...props }: AccordionContentProps): ReactElement;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/Alert.d.ts

@@ -0,0 +1,15 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type AlertProps = ComponentProps<"div"> & VariantProps<typeof alertVariants> & IDensityProps;
+declare function Alert({ density, className, variant, ...props }: AlertProps): ReactElement;
+type AlertTitleProps = ComponentProps<"div"> & IDensityProps;
+declare function AlertTitle({ density, className, ...props }: AlertTitleProps): ReactElement;
+type AlertDescriptionProps = ComponentProps<"div"> & IDensityProps;
+declare function AlertDescription({ density, className, ...props }: AlertDescriptionProps): ReactElement;
+type AlertActionProps = ComponentProps<"div"> & IDensityProps;
+declare function AlertAction({ density, className, ...props }: AlertActionProps): ReactElement;
+export { Alert, AlertTitle, AlertDescription, AlertAction };

package/dist/components/AlertDialog.d.ts

@@ -0,0 +1,28 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { AlertDialog as AlertDialogPrimitive } from "@base-ui/react/alert-dialog";
+import { Button } from "./Button.js";
+declare function AlertDialog<Payload>({ ...props }: AlertDialogPrimitive.Root.Props<Payload>): ReactElement;
+declare function AlertDialogTrigger<Payload>({ ...props }: AlertDialogPrimitive.Trigger.Props<Payload>): ReactElement;
+declare function AlertDialogPortal({ container, ...props }: AlertDialogPrimitive.Portal.Props): ReactElement;
+type AlertDialogOverlayProps = AlertDialogPrimitive.Backdrop.Props & IDensityProps;
+declare function AlertDialogOverlay({ density, className, ...props }: AlertDialogOverlayProps): ReactElement;
+type AlertDialogContentProps = AlertDialogPrimitive.Popup.Props & {
+    size?: "default" | "sm";
+} & IDensityProps;
+declare function AlertDialogContent({ density, className, size, ...props }: AlertDialogContentProps): ReactElement;
+type AlertDialogHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function AlertDialogHeader({ density, className, ...props }: AlertDialogHeaderProps): ReactElement;
+type AlertDialogFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function AlertDialogFooter({ density, className, ...props }: AlertDialogFooterProps): ReactElement;
+type AlertDialogMediaProps = ComponentProps<"div"> & IDensityProps;
+declare function AlertDialogMedia({ density, className, ...props }: AlertDialogMediaProps): ReactElement;
+type AlertDialogTitleProps = ComponentProps<typeof AlertDialogPrimitive.Title> & IDensityProps;
+declare function AlertDialogTitle({ density, className, ...props }: AlertDialogTitleProps): ReactElement;
+type AlertDialogDescriptionProps = ComponentProps<typeof AlertDialogPrimitive.Description> & IDensityProps;
+declare function AlertDialogDescription({ density, className, ...props }: AlertDialogDescriptionProps): ReactElement;
+type AlertDialogActionProps = ComponentProps<typeof Button> & IDensityProps;
+declare function AlertDialogAction({ density, className, ...props }: AlertDialogActionProps): ReactElement;
+type AlertDialogCancelProps = AlertDialogPrimitive.Close.Props & Pick<ComponentProps<typeof Button>, "variant" | "size"> & IDensityProps;
+declare function AlertDialogCancel({ density, className, variant, size, ...props }: AlertDialogCancelProps): ReactElement;
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, };

package/dist/components/AspectRatio.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentProps, ReactElement } from "react";
+export interface IAspectRatioProps extends ComponentProps<"div"> {
+    ratio: number;
+}
+export declare function AspectRatio({ ratio, className, style, ...props }: IAspectRatioProps): ReactElement;

package/dist/components/Attachment.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { Density, IDensityProps } from "../density/types.js";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./Button.js";
+declare const attachmentVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type AttachmentProps = ComponentProps<"div"> & VariantProps<typeof attachmentVariants> & IDensityProps & {
+    state?: "idle" | "uploading" | "processing" | "error" | "done";
+};
+declare function Attachment({ density, className, state, size, orientation, ...props }: AttachmentProps): ReactElement;
+declare const attachmentMediaVariants: (props?: ({
+    variant?: "icon" | "image" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type AttachmentMediaProps = ComponentProps<"div"> & VariantProps<typeof attachmentMediaVariants> & IDensityProps;
+declare function AttachmentMedia({ density, className, variant, ...props }: AttachmentMediaProps): ReactElement;
+type AttachmentContentProps = ComponentProps<"div"> & IDensityProps;
+declare function AttachmentContent({ density, className, ...props }: AttachmentContentProps): ReactElement;
+type AttachmentTitleProps = ComponentProps<"span"> & IDensityProps;
+declare function AttachmentTitle({ density, className, ...props }: AttachmentTitleProps): ReactElement;
+type AttachmentDescriptionProps = ComponentProps<"span"> & IDensityProps;
+declare function AttachmentDescription({ density, className, ...props }: AttachmentDescriptionProps): ReactElement;
+type AttachmentActionsProps = ComponentProps<"div"> & IDensityProps;
+declare function AttachmentActions({ density, className, ...props }: AttachmentActionsProps): ReactElement;
+declare function AttachmentAction({ className, variant, size, ...props }: ComponentProps<typeof Button>): ReactElement;
+type AttachmentTriggerState = {
+    slot: "attachment-trigger";
+    density?: Density;
+};
+type AttachmentTriggerProps = useRender.ComponentProps<"button", AttachmentTriggerState> & IDensityProps;
+declare function AttachmentTrigger({ density, className, render, type, ...props }: AttachmentTriggerProps): ReactElement;
+type AttachmentGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function AttachmentGroup({ density, className, ...props }: AttachmentGroupProps): ReactElement;
+export { Attachment, AttachmentGroup, AttachmentMedia, AttachmentContent, AttachmentTitle, AttachmentDescription, AttachmentActions, AttachmentAction, AttachmentTrigger, };

package/dist/components/Avatar.d.ts

@@ -0,0 +1,19 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar";
+type AvatarProps = AvatarPrimitive.Root.Props & {
+    size?: "default" | "sm" | "lg" | "preview";
+    shape?: "circle" | "square";
+} & IDensityProps;
+declare function Avatar({ density, className, size, shape, ...props }: AvatarProps): ReactElement;
+type AvatarImageProps = AvatarPrimitive.Image.Props & IDensityProps;
+declare function AvatarImage({ density, className, ...props }: AvatarImageProps): ReactElement;
+type AvatarFallbackProps = AvatarPrimitive.Fallback.Props & IDensityProps;
+declare function AvatarFallback({ density, className, ...props }: AvatarFallbackProps): ReactElement;
+type AvatarBadgeProps = ComponentProps<"span"> & IDensityProps;
+declare function AvatarBadge({ density, className, ...props }: AvatarBadgeProps): ReactElement;
+type AvatarGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function AvatarGroup({ density, className, ...props }: AvatarGroupProps): ReactElement;
+type AvatarGroupCountProps = ComponentProps<"div"> & IDensityProps;
+declare function AvatarGroupCount({ density, className, ...props }: AvatarGroupCountProps): ReactElement;
+export { Avatar, AvatarImage, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarBadge };

package/dist/components/Badge.d.ts

@@ -0,0 +1,15 @@
+import type { Density, IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "success" | "warning" | "link" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type BadgeState = {
+    slot: "badge";
+    variant: VariantProps<typeof badgeVariants>["variant"];
+    density?: Density;
+};
+type BadgeProps = useRender.ComponentProps<"span", BadgeState> & VariantProps<typeof badgeVariants> & IDensityProps;
+declare function Badge({ density, className, variant, render, ...props }: BadgeProps): ReactElement;
+export { Badge, badgeVariants };

package/dist/components/Breadcrumb.d.ts

@@ -0,0 +1,18 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+type BreadcrumbProps = ComponentProps<"nav"> & IDensityProps;
+declare function Breadcrumb({ density, className, ...props }: BreadcrumbProps): ReactElement;
+type BreadcrumbListProps = ComponentProps<"ol"> & IDensityProps;
+declare function BreadcrumbList({ density, className, ...props }: BreadcrumbListProps): ReactElement;
+type BreadcrumbItemProps = ComponentProps<"li"> & IDensityProps;
+declare function BreadcrumbItem({ density, className, ...props }: BreadcrumbItemProps): ReactElement;
+type BreadcrumbLinkProps = useRender.ComponentProps<"a"> & IDensityProps;
+declare function BreadcrumbLink({ density, className, render, ...props }: BreadcrumbLinkProps): ReactElement;
+type BreadcrumbPageProps = ComponentProps<"span"> & IDensityProps;
+declare function BreadcrumbPage({ density, className, ...props }: BreadcrumbPageProps): ReactElement;
+type BreadcrumbSeparatorProps = ComponentProps<"li"> & IDensityProps;
+declare function BreadcrumbSeparator({ density, children, className, ...props }: BreadcrumbSeparatorProps): ReactElement;
+type BreadcrumbEllipsisProps = ComponentProps<"span"> & IDensityProps;
+declare function BreadcrumbEllipsis({ density, className, ...props }: BreadcrumbEllipsisProps): ReactElement;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/components/Bubble.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { Density, IDensityProps } from "../density/types.js";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+type BubbleGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function BubbleGroup({ density, className, ...props }: BubbleGroupProps): ReactElement;
+declare const bubbleVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "muted" | "tinted" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type BubbleProps = ComponentProps<"div"> & VariantProps<typeof bubbleVariants> & IDensityProps & {
+    align?: "start" | "end";
+};
+declare function Bubble({ density, variant, align, className, ...props }: BubbleProps): ReactElement;
+type BubbleContentState = {
+    slot: "bubble-content";
+    density?: Density;
+};
+type BubbleContentProps = useRender.ComponentProps<"div", BubbleContentState> & IDensityProps;
+declare function BubbleContent({ density, className, render, ...props }: BubbleContentProps): ReactElement;
+type BubbleReactionsProps = ComponentProps<"div"> & IDensityProps & {
+    align?: "start" | "end";
+    side?: "top" | "bottom";
+};
+declare function BubbleReactions({ density, side, align, className, ...props }: BubbleReactionsProps): ReactElement;
+export { BubbleGroup, Bubble, BubbleContent, BubbleReactions };

package/dist/components/Button.d.ts

@@ -0,0 +1,14 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    truncate?: boolean | null | undefined;
+    fullWidth?: boolean | null | undefined;
+    align?: "end" | "start" | "center" | null | undefined;
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "success" | "warning" | "link" | null | undefined;
+    size?: "content" | "default" | "inline" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonProps = ButtonPrimitive.Props & VariantProps<typeof buttonVariants> & IDensityProps;
+declare function Button({ density, className, variant, size, align, truncate, fullWidth, children, ...props }: ButtonProps): ReactElement;
+export { Button, buttonVariants };

package/dist/components/ButtonGroup.d.ts

@@ -0,0 +1,14 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Separator } from "./Separator.js";
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonGroupProps = ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants> & IDensityProps;
+declare function ButtonGroup({ density, className, orientation, ...props }: ButtonGroupProps): ReactElement;
+type ButtonGroupTextProps = useRender.ComponentProps<"div"> & IDensityProps;
+declare function ButtonGroupText({ density, className, render, ...props }: ButtonGroupTextProps): ReactElement;
+declare function ButtonGroupSeparator({ density, className, orientation, ...props }: ComponentProps<typeof Separator>): ReactElement;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants };

package/dist/components/Card.d.ts

@@ -0,0 +1,19 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+type CardProps = ComponentProps<"div"> & {
+    size?: "default" | "sm";
+} & IDensityProps;
+declare function Card({ density, className, size, ...props }: CardProps): ReactElement;
+type CardHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function CardHeader({ density, className, ...props }: CardHeaderProps): ReactElement;
+type CardTitleProps = ComponentProps<"div"> & IDensityProps;
+declare function CardTitle({ density, className, ...props }: CardTitleProps): ReactElement;
+type CardDescriptionProps = ComponentProps<"div"> & IDensityProps;
+declare function CardDescription({ density, className, ...props }: CardDescriptionProps): ReactElement;
+type CardActionProps = ComponentProps<"div"> & IDensityProps;
+declare function CardAction({ density, className, ...props }: CardActionProps): ReactElement;
+type CardContentProps = ComponentProps<"div"> & IDensityProps;
+declare function CardContent({ density, className, ...props }: CardContentProps): ReactElement;
+type CardFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function CardFooter({ density, className, ...props }: CardFooterProps): ReactElement;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent };

package/dist/components/Checkbox.d.ts

@@ -0,0 +1,6 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Checkbox as CheckboxPrimitive } from "@base-ui/react/checkbox";
+type CheckboxProps = CheckboxPrimitive.Root.Props & IDensityProps;
+declare function Checkbox({ density, className, ...props }: CheckboxProps): ReactElement;
+export { Checkbox };

package/dist/components/Collapsible.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+import { Collapsible as CollapsiblePrimitive } from "@base-ui/react/collapsible";
+declare function Collapsible({ ...props }: CollapsiblePrimitive.Root.Props): ReactElement;
+declare function CollapsibleTrigger({ ...props }: CollapsiblePrimitive.Trigger.Props): ReactElement;
+declare function CollapsibleContent({ ...props }: CollapsiblePrimitive.Panel.Props): ReactElement;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/Combobox.d.ts

@@ -0,0 +1,39 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentPropsWithRef, ReactElement } from "react";
+import { Combobox as ComboboxPrimitive } from "@base-ui/react/combobox";
+declare const Combobox: typeof ComboboxPrimitive.Root;
+declare function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props): ReactElement;
+type ComboboxTriggerProps = ComboboxPrimitive.Trigger.Props & IDensityProps;
+declare function ComboboxTrigger({ density, className, children, ...props }: ComboboxTriggerProps): ReactElement;
+type ComboboxInputProps = ComboboxPrimitive.Input.Props & {
+    showTrigger?: boolean;
+    showClear?: boolean;
+    frameClassName?: string;
+    triggerLabel?: string;
+    clearLabel?: string;
+} & IDensityProps;
+declare function ComboboxInput({ density, className, children, disabled, showTrigger, showClear, frameClassName, triggerLabel, clearLabel, ...props }: ComboboxInputProps): ReactElement;
+type ComboboxContentProps = ComboboxPrimitive.Popup.Props & Pick<ComboboxPrimitive.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor"> & IDensityProps;
+declare function ComboboxContent({ density, className, side, sideOffset, align, alignOffset, anchor, ...props }: ComboboxContentProps): ReactElement;
+type ComboboxListProps = ComboboxPrimitive.List.Props & IDensityProps;
+declare function ComboboxList({ density, className, ...props }: ComboboxListProps): ReactElement;
+type ComboboxItemProps = ComboboxPrimitive.Item.Props & IDensityProps;
+declare function ComboboxItem({ density, className, children, ...props }: ComboboxItemProps): ReactElement;
+type ComboboxGroupProps = ComboboxPrimitive.Group.Props & IDensityProps;
+declare function ComboboxGroup({ density, className, ...props }: ComboboxGroupProps): ReactElement;
+type ComboboxLabelProps = ComboboxPrimitive.GroupLabel.Props & IDensityProps;
+declare function ComboboxLabel({ density, className, ...props }: ComboboxLabelProps): ReactElement;
+declare function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props): ReactElement;
+type ComboboxEmptyProps = ComboboxPrimitive.Empty.Props & IDensityProps;
+declare function ComboboxEmpty({ density, className, ...props }: ComboboxEmptyProps): ReactElement;
+type ComboboxSeparatorProps = ComboboxPrimitive.Separator.Props & IDensityProps;
+declare function ComboboxSeparator({ density, className, ...props }: ComboboxSeparatorProps): ReactElement;
+type ComboboxChipsProps = ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> & ComboboxPrimitive.Chips.Props & IDensityProps;
+declare function ComboboxChips({ density, className, ...props }: ComboboxChipsProps): ReactElement;
+type ComboboxChipProps = ComboboxPrimitive.Chip.Props & {
+    showRemove?: boolean;
+} & IDensityProps;
+declare function ComboboxChip({ density, className, children, showRemove, ...props }: ComboboxChipProps): ReactElement;
+type ComboboxChipsInputProps = ComboboxPrimitive.Input.Props & IDensityProps;
+declare function ComboboxChipsInput({ density, className, ...props }: ComboboxChipsInputProps): ReactElement;
+export { Combobox, ComboboxInput, ComboboxContent, ComboboxList, ComboboxItem, ComboboxGroup, ComboboxLabel, ComboboxCollection, ComboboxEmpty, ComboboxSeparator, ComboboxChips, ComboboxChip, ComboboxChipsInput, ComboboxTrigger, ComboboxValue, };

package/dist/components/ConfirmationDialog.d.ts

@@ -0,0 +1,11 @@
+import { type ReactElement } from "react";
+interface IConfirmationDialogProps {
+    open: boolean;
+    title: string;
+    description: string;
+    confirmLabel: string;
+    onOpenChange: (open: boolean) => void;
+    onConfirm: () => void | Promise<void>;
+}
+export declare function ConfirmationDialog({ open, title, description, confirmLabel, onOpenChange, onConfirm, }: IConfirmationDialogProps): ReactElement;
+export {};

package/dist/components/ContextMenu.d.ts

@@ -0,0 +1,24 @@
+import type { MenuLabelProps, MenuItemProps, MenuSubTriggerProps, MenuCheckboxItemProps, MenuRadioItemProps } from "../menu/types.js";
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { ContextMenu as ContextMenuPrimitive } from "@base-ui/react/context-menu";
+declare function ContextMenu({ ...props }: ContextMenuPrimitive.Root.Props): ReactElement;
+declare function ContextMenuPortal({ container, ...props }: ContextMenuPrimitive.Portal.Props): ReactElement;
+type ContextMenuTriggerProps = ContextMenuPrimitive.Trigger.Props & IDensityProps;
+declare function ContextMenuTrigger({ density, className, ...props }: ContextMenuTriggerProps): ReactElement;
+type ContextMenuContentProps = ContextMenuPrimitive.Popup.Props & Pick<ContextMenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & IDensityProps;
+declare function ContextMenuContent({ density, className, align, alignOffset, side, sideOffset, ...props }: ContextMenuContentProps): ReactElement;
+declare function ContextMenuGroup({ ...props }: ContextMenuPrimitive.Group.Props): ReactElement;
+declare function ContextMenuLabel({ density, className, inset, ...props }: MenuLabelProps): ReactElement;
+declare function ContextMenuItem({ density, className, inset, variant, ...props }: MenuItemProps): ReactElement;
+declare function ContextMenuSub({ ...props }: ContextMenuPrimitive.SubmenuRoot.Props): ReactElement;
+declare function ContextMenuSubTrigger({ density, className, inset, children, ...props }: MenuSubTriggerProps): ReactElement;
+declare function ContextMenuSubContent({ ...props }: ComponentProps<typeof ContextMenuContent>): ReactElement;
+declare function ContextMenuCheckboxItem({ density, className, children, checked, inset, ...props }: MenuCheckboxItemProps): ReactElement;
+declare function ContextMenuRadioGroup({ ...props }: ContextMenuPrimitive.RadioGroup.Props): ReactElement;
+declare function ContextMenuRadioItem({ density, className, children, inset, ...props }: MenuRadioItemProps): ReactElement;
+type ContextMenuSeparatorProps = ContextMenuPrimitive.Separator.Props & IDensityProps;
+declare function ContextMenuSeparator({ density, className, ...props }: ContextMenuSeparatorProps): ReactElement;
+type ContextMenuShortcutProps = ComponentProps<"span"> & IDensityProps;
+declare function ContextMenuShortcut({ density, className, ...props }: ContextMenuShortcutProps): ReactElement;
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

package/dist/components/DensityProvider.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode, ReactElement } from "react";
+import type { Density } from "../density/types.js";
+export interface IDensityProviderProps {
+    children: ReactNode;
+    density?: Density;
+}
+export declare function DensityProvider({ children, density }: IDensityProviderProps): ReactElement;

package/dist/components/Dialog.d.ts

@@ -0,0 +1,25 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+declare function Dialog<Payload>({ ...props }: DialogPrimitive.Root.Props<Payload>): ReactElement;
+declare function DialogTrigger<Payload>({ ...props }: DialogPrimitive.Trigger.Props<Payload>): ReactElement;
+declare function DialogPortal({ container, ...props }: DialogPrimitive.Portal.Props): ReactElement;
+declare function DialogClose({ ...props }: DialogPrimitive.Close.Props): ReactElement;
+type DialogOverlayProps = DialogPrimitive.Backdrop.Props & IDensityProps;
+declare function DialogOverlay({ density, className, ...props }: DialogOverlayProps): ReactElement;
+type DialogContentProps = DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+    size?: "default" | "wide" | "narrow" | "fullscreen";
+} & IDensityProps;
+declare function DialogContent({ density, className, children, showCloseButton, size, ...props }: DialogContentProps): ReactElement;
+type DialogHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function DialogHeader({ density, className, ...props }: DialogHeaderProps): ReactElement;
+type DialogFooterProps = ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+} & IDensityProps;
+declare function DialogFooter({ density, className, showCloseButton, children, ...props }: DialogFooterProps): ReactElement;
+type DialogTitleProps = DialogPrimitive.Title.Props & IDensityProps;
+declare function DialogTitle({ density, className, ...props }: DialogTitleProps): ReactElement;
+type DialogDescriptionProps = DialogPrimitive.Description.Props & IDensityProps;
+declare function DialogDescription({ density, className, ...props }: DialogDescriptionProps): ReactElement;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

package/dist/components/DirectionProvider.d.ts

@@ -0,0 +1 @@
+export { DirectionProvider, useDirection } from "@base-ui/react/direction-provider";

package/dist/components/DragDropPreview.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from "react";
+interface IDragDropPreviewProps {
+    labels: readonly string[];
+    maxItems?: number;
+}
+export declare function DragDropPreview({ labels, maxItems }: IDragDropPreviewProps): ReactElement;
+export {};

package/dist/components/DragDropProvider.d.ts

@@ -0,0 +1,6 @@
+import { type PropsWithChildren, type ReactElement } from "react";
+interface IDragDropProviderProps extends PropsWithChildren {
+    maxPreviewItems?: number;
+}
+export declare function DragDropProvider({ children, maxPreviewItems }: IDragDropProviderProps): ReactElement;
+export {};

package/dist/components/DragSource.d.ts

@@ -0,0 +1,10 @@
+import { useRender } from "@base-ui/react/use-render";
+import type { ReactElement } from "react";
+import type { IDragSourceOptions } from "../drag-drop/types.js";
+type DragSourceState = {
+    slot: "drag-source";
+    dragging: boolean;
+};
+type DragSourceProps = Omit<useRender.ComponentProps<"div", DragSourceState>, "onDragStart" | "onDragEnd"> & IDragSourceOptions;
+export declare function DragSource({ type, data, labels, effectAllowed, disabled, render, ...props }: DragSourceProps): ReactElement;
+export {};

package/dist/components/Drawer.d.ts

@@ -0,0 +1,25 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Drawer as DrawerPrimitive } from "@base-ui/react/drawer";
+type DrawerProps<Payload> = DrawerPrimitive.Root.Props<Payload> & {
+    showSwipeHandle?: boolean;
+};
+declare function Drawer<Payload>({ modal, showSwipeHandle, snapPoints, swipeDirection, ...props }: DrawerProps<Payload>): ReactElement;
+declare function DrawerTrigger<Payload>({ ...props }: DrawerPrimitive.Trigger.Props<Payload>): ReactElement;
+declare function DrawerPortal({ container, ...props }: DrawerPrimitive.Portal.Props): ReactElement;
+declare function DrawerClose({ ...props }: DrawerPrimitive.Close.Props): ReactElement;
+type DrawerOverlayProps = DrawerPrimitive.Backdrop.Props & IDensityProps;
+declare function DrawerOverlay({ density, className, ...props }: DrawerOverlayProps): ReactElement;
+type DrawerSwipeHandleProps = ComponentProps<"div"> & IDensityProps;
+declare function DrawerSwipeHandle({ density, className, ...props }: DrawerSwipeHandleProps): ReactElement;
+type DrawerContentProps = DrawerPrimitive.Popup.Props & IDensityProps;
+declare function DrawerContent({ density, className, children, ...props }: DrawerContentProps): ReactElement;
+type DrawerHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function DrawerHeader({ density, className, ...props }: DrawerHeaderProps): ReactElement;
+type DrawerFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function DrawerFooter({ density, className, ...props }: DrawerFooterProps): ReactElement;
+type DrawerTitleProps = DrawerPrimitive.Title.Props & IDensityProps;
+declare function DrawerTitle({ density, className, ...props }: DrawerTitleProps): ReactElement;
+type DrawerDescriptionProps = DrawerPrimitive.Description.Props & IDensityProps;
+declare function DrawerDescription({ density, className, ...props }: DrawerDescriptionProps): ReactElement;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerSwipeHandle, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };

package/dist/components/DropTarget.d.ts

@@ -0,0 +1,11 @@
+import { useRender } from "@base-ui/react/use-render";
+import type { ReactElement } from "react";
+import type { IDropTargetOptions } from "../drag-drop/types.js";
+type DropTargetState = {
+    slot: "drop-target";
+    over: boolean;
+    effect: DataTransfer["dropEffect"];
+};
+type DropTargetProps = Omit<useRender.ComponentProps<"div", DropTargetState>, "onDrop"> & IDropTargetOptions;
+export declare function DropTarget({ accept, canDrop, getDropEffect, onDrop, render, ...props }: DropTargetProps): ReactElement;
+export {};