@oneplatformdev/ui 0.0.1-beta.11

package/Accordion/Accordion.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/Accordion/Accordion.mjs

@@ -0,0 +1,46 @@
+import { jsx as a, jsxs as d } from "react/jsx-runtime";
+import * as i from "react";
+import * as e from "@radix-ui/react-accordion";
+import { ChevronDown as m } from "lucide-react";
+import { cn as s } from "@oneplatformdev/utils";
+const g = e.Root, c = i.forwardRef(({ className: o, ...t }, r) => /* @__PURE__ */ a(
+  e.Item,
+  {
+    ref: r,
+    className: s("border-b", o),
+    ...t
+  }
+));
+c.displayName = "AccordionItem";
+const l = i.forwardRef(({ className: o, children: t, ...r }, n) => /* @__PURE__ */ a(e.Header, { className: "flex", children: /* @__PURE__ */ d(
+  e.Trigger,
+  {
+    ref: n,
+    className: s(
+      "flex flex-1 items-center justify-between py-4 text-sm font-medium transition-all hover:underline text-left [&[data-state=open]>svg]:rotate-180",
+      o
+    ),
+    ...r,
+    children: [
+      t,
+      /* @__PURE__ */ a(m, { className: "h-4 w-4 shrink-0 text-muted-foreground transition-transform duration-200" })
+    ]
+  }
+) }));
+l.displayName = e.Trigger.displayName;
+const f = i.forwardRef(({ className: o, children: t, ...r }, n) => /* @__PURE__ */ a(
+  e.Content,
+  {
+    ref: n,
+    className: "overflow-hidden text-sm data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down",
+    ...r,
+    children: /* @__PURE__ */ a("div", { className: s("pb-4 pt-0", o), children: t })
+  }
+));
+f.displayName = e.Content.displayName;
+export {
+  g as Accordion,
+  f as AccordionContent,
+  c as AccordionItem,
+  l as AccordionTrigger
+};

package/Accordion/index.d.ts

@@ -0,0 +1 @@
+export * from './Accordion';

package/Accordion/index.mjs

@@ -0,0 +1,7 @@
+import { Accordion as r, AccordionContent as n, AccordionItem as i, AccordionTrigger as d } from "./Accordion.mjs";
+export {
+  r as Accordion,
+  n as AccordionContent,
+  i as AccordionItem,
+  d as AccordionTrigger
+};

package/Accordion/package.json

@@ -0,0 +1,7 @@
+{
+  "sideEffects": false,
+  "main": "./index.mjs",
+  "module": "./index.mjs",
+  "default": "./index.mjs",
+  "types": "./index.d.ts"
+}

package/Alert/Alert.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+export declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+export declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;

package/Alert/Alert.mjs

@@ -0,0 +1,37 @@
+import { jsx as a } from "react/jsx-runtime";
+import * as i from "react";
+import { cn as l } from "@oneplatformdev/utils";
+import { alertVariants as m } from "./alertVariants.mjs";
+const s = i.forwardRef(({ className: e, variant: r, ...t }, o) => /* @__PURE__ */ a(
+  "div",
+  {
+    ref: o,
+    role: "alert",
+    className: l(m({ variant: r }), e),
+    ...t
+  }
+));
+s.displayName = "Alert";
+const n = i.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ a(
+  "h5",
+  {
+    ref: t,
+    className: l("mb-1 font-medium leading-none tracking-tight", e),
+    ...r
+  }
+));
+n.displayName = "AlertTitle";
+const d = i.forwardRef(({ className: e, ...r }, t) => /* @__PURE__ */ a(
+  "div",
+  {
+    ref: t,
+    className: l("text-sm [&_p]:leading-relaxed", e),
+    ...r
+  }
+));
+d.displayName = "AlertDescription";
+export {
+  s as Alert,
+  d as AlertDescription,
+  n as AlertTitle
+};

package/Alert/alertVariants.d.ts

@@ -0,0 +1,4 @@
+export declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export default alertVariants;

package/Alert/alertVariants.mjs

@@ -0,0 +1,19 @@
+import { cva as t } from "class-variance-authority";
+const r = t(
+  "relative w-full rounded-lg border px-4 py-3 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground [&>svg~*]:pl-7",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        destructive: "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+export {
+  r as alertVariants,
+  r as default
+};

package/Alert/index.d.ts

@@ -0,0 +1 @@
+export * from './Alert';

package/Alert/index.mjs

@@ -0,0 +1,6 @@
+import { Alert as t, AlertDescription as l, AlertTitle as i } from "./Alert.mjs";
+export {
+  t as Alert,
+  l as AlertDescription,
+  i as AlertTitle
+};

package/Alert/package.json

@@ -0,0 +1,7 @@
+{
+  "sideEffects": false,
+  "main": "./index.mjs",
+  "module": "./index.mjs",
+  "default": "./index.mjs",
+  "types": "./index.d.ts"
+}

package/AlertDialog/AlertDialog.d.ts

@@ -0,0 +1,65 @@
+import { AlertDialogProps } from './AlertDialog.types';
+import { FC, PropsWithChildren } from 'react';
+
+/**
+ * Component for show Alert Dialog.
+ * @public
+ * @see [Documentation](#)
+ * @example
+ * > Import:
+ * ```tsx
+ *    import { AlertDialog } from '@oneplatformdev/ui/AlertDialog';
+ * ```
+ * > Simple example:
+ * ```tsx
+ *    <AlertDialog
+ *         trigger={'Trigger text'} // may be any ReactNode | Button | string
+ *         variant='alert' // 'confirm' (default) | 'alert' | 'destructive'
+ *         title='Dialog title'
+ *         description='Description text...'
+ *       />
+ * ```
+ * > Base example:
+ * ```tsx
+ *   <AlertDialog
+ *         trigger={<Button variant="outline">Simple Trigger</Button>}
+ *         title='Dialog title'
+ *         description='Description text...'
+ *         onCancel={(event) => console.log(event, 'Cancel')}
+ *         onConfirm={(event) => console.log(event, 'Confirm')}
+ *       />
+ * ```
+ * > Trigger example: Button with icon children
+ * ```tsx
+ *      <AlertDialog
+ *         trigger={<Button variant="outline" size="icon"><PencilLine /></Button>}
+ *         title="Dialog title with icon trigger"
+ *         description="Description text..."
+ *         onCancel={(event) => console.log(event, 'Cancel')}
+ *         onConfirm={(event) => console.log(event, 'Confirm')}
+ *       />
+ * ```
+ *
+ * > Full content example:
+ * ```tsx
+ *    <AlertDialog trigger={<Button variant="outline">Full Content Trigger</Button>}>
+ *      Full Content...
+ *     </AlertDialog>
+ * ```
+ *
+ * > Full control example:
+ * ```tsx
+ *       <AlertDialog
+ *         open={true}
+ *         onOpenChange={(nextState) => console.log(nextState)}
+ *         trigger={<Button variant="outline">Control Trigger</Button>}
+ *         header={<div>Custom Header</div>}
+ *         footer={[
+ *           <Button key='cancel' variant="outline" onClick={() => {}}>On Action</Button>,
+ *           <Button key='action' variant="outline" onClick={() => {}}>On Action</Button>,
+ *         ]}
+ *       />
+ * ```
+ */
+export declare const AlertDialog: FC<PropsWithChildren<AlertDialogProps>>;
+export default AlertDialog;

package/AlertDialog/AlertDialog.mjs

@@ -0,0 +1,97 @@
+import { jsxs as g, jsx as t } from "react/jsx-runtime";
+import { cloneElement as a, useId as j, Children as y } from "react";
+import { AlertDialogRoot as E, AlertDialogContent as u, AlertDialogTrigger as v, AlertDialogHeader as f, AlertDialogTitle as B, AlertDialogDescription as R, AlertDialogFooter as A, AlertDialogAction as D, AlertDialogCancel as k } from "./AlertDialogRoot.mjs";
+import { isValidReactElement as s } from "@oneplatformdev/utils";
+const F = (o) => {
+  const { slotProps: e = {}, children: r } = o, i = e.trigger ?? {};
+  return s(r, v) ? a(
+    r,
+    {
+      ...r.props || {},
+      ...i
+    }
+  ) : /* @__PURE__ */ t(v, { asChild: !0, children: r });
+}, H = (o) => {
+  const {
+    title: e = "",
+    description: r = "",
+    slotProps: i = {},
+    children: l
+  } = o, n = i.header ?? {}, d = i.title ?? {}, c = i.description ?? {};
+  return l ? s(l, f) ? a(
+    l,
+    { ...l.props || {}, ...n }
+  ) : /* @__PURE__ */ t(f, { ...n, children: l }) : /* @__PURE__ */ g(f, { children: [
+    e && s(e, B) ? a(
+      e,
+      { ...e.props || {}, ...d }
+    ) : /* @__PURE__ */ t(B, { ...d, children: e }),
+    r && s(r, R) ? a(
+      r,
+      { ...r.props || {}, ...c }
+    ) : /* @__PURE__ */ t(R, { ...c, children: r })
+  ] });
+}, I = (o) => {
+  const {
+    slotProps: e = {},
+    children: r,
+    onCancel: i,
+    onConfirm: l,
+    cancelLabel: n = "Cancel",
+    actionLabel: d = "Continue",
+    variant: c = "confirm"
+  } = o, x = j(), m = e.footer ?? {}, T = e.cancelButton ?? {}, C = e.actionButton ?? {};
+  return r ? s(r, A) ? a(
+    r,
+    { ...r.props || {}, ...m }
+  ) : /* @__PURE__ */ t(A, { ...m, children: y.map(r, (p, b) => {
+    if (!p || !s(p)) return;
+    const h = p, P = a(h, { ...h.props || {}, key: h.key || `footer-${x}-action-${b}` });
+    return s(p, D) || s(p, k) ? P : /* @__PURE__ */ t(D, { asChild: !0, children: P });
+  }) }) : /* @__PURE__ */ g(A, { children: [
+    c !== "alert" && /* @__PURE__ */ t(
+      k,
+      {
+        variant: "ghost",
+        onClick: i,
+        ...T,
+        children: n
+      }
+    ),
+    /* @__PURE__ */ t(
+      D,
+      {
+        onClick: l,
+        ...C,
+        variant: C.variant || c === "destructive" ? "destructive" : "default",
+        children: d
+      }
+    )
+  ] });
+}, w = (o) => {
+  const {
+    trigger: e,
+    header: r,
+    footer: i,
+    slotProps: l = {},
+    children: n,
+    ...d
+  } = o, c = l.content ?? {};
+  return /* @__PURE__ */ g(E, { ...d, children: [
+    /* @__PURE__ */ t(F, { ...o, children: e }),
+    n ? s(n, u) ? a(
+      n,
+      {
+        ...n.props || {},
+        ...c
+      }
+    ) : /* @__PURE__ */ t(u, { ...c, children: n }) : /* @__PURE__ */ g(u, { ...c, children: [
+      /* @__PURE__ */ t(H, { ...o, children: r }),
+      /* @__PURE__ */ t(I, { ...o, children: i })
+    ] })
+  ] });
+};
+export {
+  w as AlertDialog,
+  w as default
+};

package/AlertDialog/AlertDialog.types.d.ts

@@ -0,0 +1,53 @@
+import { AlertDialogTrigger, AlertDialogTitle, AlertDialogRoot, AlertDialogDescription, AlertDialogHeader, AlertDialogFooter, AlertDialogCancel, AlertDialogAction, AlertDialogContent } from './AlertDialogRoot';
+import { ComponentPropsWithoutRef, ReactNode, MouseEvent } from 'react';
+
+export type AlertDialogRootProps = ComponentPropsWithoutRef<typeof AlertDialogRoot>;
+export type AlertDialogTriggerProps = ComponentPropsWithoutRef<typeof AlertDialogTrigger>;
+export type AlertDialogContentProps = ComponentPropsWithoutRef<typeof AlertDialogContent>;
+export type AlertDialogHeaderProps = ComponentPropsWithoutRef<typeof AlertDialogHeader>;
+export type AlertDialogTitleProps = ComponentPropsWithoutRef<typeof AlertDialogTitle>;
+export type AlertDialogDescriptionProps = ComponentPropsWithoutRef<typeof AlertDialogDescription>;
+export type AlertDialogFooterProps = ComponentPropsWithoutRef<typeof AlertDialogFooter>;
+export type AlertDialogCancelProps = ComponentPropsWithoutRef<typeof AlertDialogCancel>;
+export type AlertDialogActionProps = ComponentPropsWithoutRef<typeof AlertDialogAction>;
+export interface AlertDialogProps extends Partial<AlertDialogRootProps> {
+    /** Alert Dialog Type. */
+    variant?: 'confirm' | 'alert' | 'destructive';
+    /** CancelButton label. */
+    cancelLabel?: ReactNode;
+    /** ActionButton label. */
+    actionLabel?: ReactNode;
+    /** CancelButton onClick event. */
+    onCancel?: (event: MouseEvent<HTMLButtonElement>) => void;
+    /** ActionButton onClick event. */
+    onConfirm?: (event: MouseEvent<HTMLButtonElement>) => void;
+    /** The trigger to open alert dialog. */
+    trigger?: ReactNode;
+    /** Alert Dialog Header. */
+    header?: ReactNode;
+    /** Alert Dialog Header Title. */
+    title?: ReactNode;
+    /** Alert Dialog Header Description. */
+    description?: ReactNode;
+    /** Alert Dialog Footer. */
+    footer?: ReactNode;
+    /** Alert Dialog Slots props. */
+    slotProps?: {
+        /** Alert Dialog Slot props for AlertDialogTrigger. */
+        trigger?: AlertDialogTriggerProps;
+        /** Alert Dialog Slot props for AlertDialogContentProps. */
+        content?: AlertDialogContentProps;
+        /** Alert Dialog Slot props for AlertDialogTrigger. */
+        header?: AlertDialogHeaderProps;
+        /** Alert Dialog Slot props for AlertDialogFooter. */
+        footer?: AlertDialogFooterProps;
+        /** Alert Dialog Slot props for AlertDialogTitle. */
+        title?: AlertDialogTitleProps;
+        /** Alert Dialog Slot props for AlertDialogDescriptionProps. */
+        description?: AlertDialogDescriptionProps;
+        /** Alert Dialog Slot props for AlertDialogCancelProps. */
+        cancelButton?: AlertDialogCancelProps;
+        /** Alert Dialog Slot props for AlertDialogActionProps. */
+        actionButton?: AlertDialogActionProps;
+    };
+}

package/AlertDialog/AlertDialogRoot.d.ts

@@ -0,0 +1,21 @@
+import { ButtonProps } from '../Button';
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialogRoot: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialogRoot, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/AlertDialog/AlertDialogRoot.mjs

@@ -0,0 +1,114 @@
+import { jsx as l, jsxs as c } from "react/jsx-runtime";
+import * as i from "react";
+import * as e from "@radix-ui/react-alert-dialog";
+import { cn as s } from "@oneplatformdev/utils";
+import "../Button/Button.mjs";
+import { buttonVariants as n } from "../Button/buttonVariants.mjs";
+const v = e.Root, C = e.Trigger, f = e.Portal, m = i.forwardRef(({ className: a, ...t }, o) => /* @__PURE__ */ l(
+  e.Overlay,
+  {
+    className: s(
+      "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      a
+    ),
+    ...t,
+    ref: o
+  }
+));
+m.displayName = e.Overlay.displayName;
+const p = i.forwardRef(({ className: a, ...t }, o) => /* @__PURE__ */ c(f, { children: [
+  /* @__PURE__ */ l(m, {}),
+  /* @__PURE__ */ l(
+    e.Content,
+    {
+      ref: o,
+      className: s(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        a
+      ),
+      ...t
+    }
+  )
+] }));
+p.displayName = e.Content.displayName;
+const g = ({
+  className: a,
+  ...t
+}) => /* @__PURE__ */ l(
+  "div",
+  {
+    className: s(
+      "flex flex-col space-y-2 text-center sm:text-left",
+      a
+    ),
+    ...t
+  }
+);
+g.displayName = "AlertDialogHeader";
+const N = ({
+  className: a,
+  ...t
+}) => /* @__PURE__ */ l(
+  "div",
+  {
+    className: s(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      a
+    ),
+    ...t
+  }
+);
+N.displayName = "AlertDialogFooter";
+const y = i.forwardRef(({ className: a, ...t }, o) => /* @__PURE__ */ l(
+  e.Title,
+  {
+    ref: o,
+    className: s("text-lg font-semibold", a),
+    ...t
+  }
+));
+y.displayName = e.Title.displayName;
+const x = i.forwardRef(({ className: a, ...t }, o) => /* @__PURE__ */ l(
+  e.Description,
+  {
+    ref: o,
+    className: s("text-sm text-muted-foreground", a),
+    ...t
+  }
+));
+x.displayName = e.Description.displayName;
+const A = i.forwardRef(({ className: a, variant: t, size: o, ...r }, d) => /* @__PURE__ */ l(
+  e.Action,
+  {
+    ref: d,
+    className: s(n({ variant: t, size: o }), a),
+    ...r
+  }
+));
+A.displayName = e.Action.displayName;
+const D = i.forwardRef(({ className: a, variant: t = "outline", size: o, ...r }, d) => /* @__PURE__ */ l(
+  e.Cancel,
+  {
+    ref: d,
+    className: s(
+      n({ variant: t, size: o }),
+      "mt-2 sm:mt-0",
+      a
+    ),
+    ...r
+  }
+));
+D.displayName = e.Cancel.displayName;
+export {
+  A as AlertDialogAction,
+  D as AlertDialogCancel,
+  p as AlertDialogContent,
+  x as AlertDialogDescription,
+  N as AlertDialogFooter,
+  g as AlertDialogHeader,
+  m as AlertDialogOverlay,
+  f as AlertDialogPortal,
+  v as AlertDialogRoot,
+  y as AlertDialogTitle,
+  C as AlertDialogTrigger
+};

package/AlertDialog/index.d.ts

@@ -0,0 +1,3 @@
+export { AlertDialogRoot, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, } from './AlertDialogRoot';
+export * from './AlertDialog';
+export type * from './AlertDialog.types';

package/AlertDialog/index.mjs

@@ -0,0 +1,16 @@
+import { AlertDialogAction as e, AlertDialogCancel as r, AlertDialogContent as t, AlertDialogDescription as i, AlertDialogFooter as a, AlertDialogHeader as g, AlertDialogOverlay as A, AlertDialogPortal as D, AlertDialogRoot as n, AlertDialogTitle as c, AlertDialogTrigger as p } from "./AlertDialogRoot.mjs";
+import { AlertDialog as m } from "./AlertDialog.mjs";
+export {
+  m as AlertDialog,
+  e as AlertDialogAction,
+  r as AlertDialogCancel,
+  t as AlertDialogContent,
+  i as AlertDialogDescription,
+  a as AlertDialogFooter,
+  g as AlertDialogHeader,
+  A as AlertDialogOverlay,
+  D as AlertDialogPortal,
+  n as AlertDialogRoot,
+  c as AlertDialogTitle,
+  p as AlertDialogTrigger
+};

package/AlertDialog/package.json

@@ -0,0 +1,7 @@
+{
+  "sideEffects": false,
+  "main": "./index.mjs",
+  "module": "./index.mjs",
+  "default": "./index.mjs",
+  "types": "./index.d.ts"
+}

package/AreaChart/AreaChart.d.ts

@@ -0,0 +1,4 @@
+import { AreaChartProps } from './AreaChart.types';
+import { FC } from 'react';
+
+export declare const AreaChart: FC<AreaChartProps>;

package/AreaChart/AreaChart.mjs

@@ -0,0 +1,27 @@
+import { jsx as t, jsxs as a } from "react/jsx-runtime";
+import { AreaChart as s, CartesianGrid as n, XAxis as l, YAxis as h, Area as p } from "recharts";
+import { ChartContainer as d, ChartTooltip as f, ChartTooltipContent as c } from "../Chart/Chart.mjs";
+const k = ({ data: o, config: i }) => /* @__PURE__ */ t(d, { config: i, className: "h-[350px] w-full", children: /* @__PURE__ */ a(s, { data: o, width: 808, height: 350, margin: { top: 10, right: 10, left: 0, bottom: 0 }, children: [
+  /* @__PURE__ */ t("defs", { children: Object.entries(i).map(([e, { color: r }]) => /* @__PURE__ */ a("linearGradient", { id: `${e}Gradient`, x1: "0", y1: "0", x2: "0", y2: "1", children: [
+    /* @__PURE__ */ t("stop", { offset: "5%", stopColor: r, stopOpacity: 0.8 }),
+    /* @__PURE__ */ t("stop", { offset: "95%", stopColor: r, stopOpacity: 0.1 })
+  ] }, e)) }),
+  /* @__PURE__ */ t(n, { strokeDasharray: "none", stroke: "gray", strokeWidth: 0.5, vertical: !0, horizontal: !0 }),
+  /* @__PURE__ */ t(l, { dataKey: "month", axisLine: !1, tickLine: !1, tick: { fontSize: 12 } }),
+  /* @__PURE__ */ t(h, { axisLine: !1, tickLine: !1, tick: { fontSize: 12 } }),
+  /* @__PURE__ */ t(f, { content: /* @__PURE__ */ t(c, {}) }),
+  Object.entries(i).map(([e, { color: r }]) => /* @__PURE__ */ t(
+    p,
+    {
+      type: "monotone",
+      dataKey: e,
+      stroke: r,
+      fill: `url(#${e}Gradient)`,
+      strokeWidth: 3
+    },
+    e
+  ))
+] }) });
+export {
+  k as AreaChart
+};

package/AreaChart/AreaChart.types.d.ts

@@ -0,0 +1,15 @@
+export interface AreaChartData {
+    month: string;
+    [key: string]: number | string;
+}
+export interface AreaChartConfigItem {
+    label: string;
+    color: string;
+}
+export interface AreaChartConfig {
+    [key: string]: AreaChartConfigItem;
+}
+export interface AreaChartProps {
+    data: AreaChartData[];
+    config: AreaChartConfig;
+}

package/AreaChart/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AreaChart';
+export type * from './AreaChart.types';

package/AreaChart/index.mjs

@@ -0,0 +1,4 @@
+import { AreaChart as e } from "./AreaChart.mjs";
+export {
+  e as AreaChart
+};

package/AreaChart/package.json

@@ -0,0 +1,7 @@
+{
+  "sideEffects": false,
+  "main": "./index.mjs",
+  "module": "./index.mjs",
+  "default": "./index.mjs",
+  "types": "./index.d.ts"
+}

package/Aside/Aside.d.ts

@@ -0,0 +1,4 @@
+import { AsideProps } from './Aside.types';
+
+export declare const Aside: React.FC<React.PropsWithChildren<AsideProps>>;
+export default Aside;

package/Aside/Aside.mjs

@@ -0,0 +1,23 @@
+import { jsxs as e, jsx as o } from "react/jsx-runtime";
+import { SidebarProvider as s, SidebarInset as n } from "../Sidebar/Sidebar.mjs";
+const c = (d) => {
+  const {
+    children: l,
+    header: r,
+    sidebar: i
+  } = d;
+  return /* @__PURE__ */ e(s, { children: [
+    !!i && i,
+    /* @__PURE__ */ e(n, { children: [
+      !!r && r,
+      /* @__PURE__ */ e("section", { className: "flex flex-1 flex-col gap-4 p-4 pt-0", children: [
+        /* @__PURE__ */ o("div", { children: "test build" }),
+        l
+      ] })
+    ] })
+  ] });
+};
+export {
+  c as Aside,
+  c as default
+};