@admin-layout/tailwind-ui 10.1.1-alpha.9 → 11.2.1-alpha.1

package/lib/shardui/card.js

@@ -0,0 +1,54 @@
+import*as React from'react';import'../utils/isBrowser/index.js';import {cn}from'../utils/util.js';import'fast-deep-equal/react.js';const Card = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement("div", {
+  ref: ref,
+  className: cn('rounded-lg border bg-card text-card-foreground shadow-sm', className),
+  ...props
+}));
+Card.displayName = 'Card';
+const CardHeader = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement("div", {
+  ref: ref,
+  className: cn('flex flex-col space-y-1.5 p-6', className),
+  ...props
+}));
+CardHeader.displayName = 'CardHeader';
+const CardTitle = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement("h3", {
+  ref: ref,
+  className: cn('text-2xl font-semibold leading-none tracking-tight', className),
+  ...props
+}));
+CardTitle.displayName = 'CardTitle';
+const CardDescription = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement("p", {
+  ref: ref,
+  className: cn('text-sm text-muted-foreground', className),
+  ...props
+}));
+CardDescription.displayName = 'CardDescription';
+const CardContent = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement("div", {
+  ref: ref,
+  className: cn('p-6 pt-0', className),
+  ...props
+}));
+CardContent.displayName = 'CardContent';
+const CardFooter = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement("div", {
+  ref: ref,
+  className: cn('flex items-center p-6 pt-0', className),
+  ...props
+}));
+CardFooter.displayName = 'CardFooter';export{Card,CardContent,CardDescription,CardFooter,CardHeader,CardTitle};//# sourceMappingURL=card.js.map

package/lib/shardui/card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"card.js","sources":["../../src/shardui/card.tsx"],"sourcesContent":[null],"names":[],"mappings":"mIASA,MAAA,IAAA,GAAA,KAAM,CAAA,UAAU,CAAA,CAAA;AAOhB,EAAA,SAAA;AAOA,EAAA,GAAA;AAOA,CAAA,EAAA,GAAA,KAAA,KAAM,CAAA,aAAW,CAAA,KAAA,EAAA;AAKjB,EAAA,GAAA,EAAA,GAAA;AAOA,EAAA,SAAS,EAAI,EAAE,CAAA,0DAAoD,EAAA,SAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/shardui/carousel.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import useEmblaCarousel, { type UseEmblaCarouselType } from 'embla-carousel-react';
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: 'horizontal' | 'vertical';
+    setApi?: (api: CarouselApi) => void;
+};
+declare const Carousel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & CarouselProps & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselPrevious: React.ForwardRefExoticComponent<Omit<import("./button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React.ForwardRefExoticComponent<Omit<import("./button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext };
+//# sourceMappingURL=carousel.d.ts.map

package/lib/shardui/carousel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carousel.d.ts","sourceRoot":"","sources":["../../src/shardui/carousel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,gBAAgB,EAAE,EAAE,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAMnF,KAAK,WAAW,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAC3C,KAAK,qBAAqB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACjE,KAAK,eAAe,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAChD,KAAK,cAAc,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAE/C,KAAK,aAAa,GAAG;IACjB,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,WAAW,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;IACxC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,CAAC;CACvC,CAAC;AAuBF,QAAA,MAAM,QAAQ,6HA0Fb,CAAC;AAGF,QAAA,MAAM,eAAe,6GAcpB,CAAC;AAGF,QAAA,MAAM,YAAY,6GAkBjB,CAAC;AAGF,QAAA,MAAM,gBAAgB,gKAyBrB,CAAC;AAGF,QAAA,MAAM,YAAY,gKAyBjB,CAAC;AAGF,OAAO,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,CAAC"}

package/lib/shardui/carousel.js

@@ -0,0 +1,169 @@
+import*as React from'react';import useEmblaCarousel from'embla-carousel-react';import {ArrowLeft,ArrowRight}from'lucide-react';import'../utils/isBrowser/index.js';import {cn}from'../utils/util.js';import'fast-deep-equal/react.js';import {Button}from'./button.js';const CarouselContext = React.createContext(null);
+function useCarousel() {
+  const context = React.useContext(CarouselContext);
+  if (!context) {
+    throw new Error('useCarousel must be used within a <Carousel />');
+  }
+  return context;
+}
+const Carousel = React.forwardRef(({
+  orientation = 'horizontal',
+  opts,
+  setApi,
+  plugins,
+  className,
+  children,
+  ...props
+}, ref) => {
+  const [carouselRef, api] = useEmblaCarousel({
+    ...opts,
+    axis: orientation === 'horizontal' ? 'x' : 'y'
+  }, plugins);
+  const [canScrollPrev, setCanScrollPrev] = React.useState(false);
+  const [canScrollNext, setCanScrollNext] = React.useState(false);
+  const onSelect = React.useCallback(api => {
+    if (!api) {
+      return;
+    }
+    setCanScrollPrev(api.canScrollPrev());
+    setCanScrollNext(api.canScrollNext());
+  }, []);
+  const scrollPrev = React.useCallback(() => {
+    api?.scrollPrev();
+  }, [api]);
+  const scrollNext = React.useCallback(() => {
+    api?.scrollNext();
+  }, [api]);
+  const handleKeyDown = React.useCallback(event => {
+    if (event.key === 'ArrowLeft') {
+      event.preventDefault();
+      scrollPrev();
+    } else if (event.key === 'ArrowRight') {
+      event.preventDefault();
+      scrollNext();
+    }
+  }, [scrollPrev, scrollNext]);
+  React.useEffect(() => {
+    if (!api || !setApi) {
+      return;
+    }
+    setApi(api);
+  }, [api, setApi]);
+  React.useEffect(() => {
+    if (!api) {
+      return;
+    }
+    onSelect(api);
+    api.on('reInit', onSelect);
+    api.on('select', onSelect);
+    return () => {
+      api?.off('select', onSelect);
+    };
+  }, [api, onSelect]);
+  return React.createElement(CarouselContext.Provider, {
+    value: {
+      carouselRef,
+      api: api,
+      opts,
+      orientation: orientation || (opts?.axis === 'y' ? 'vertical' : 'horizontal'),
+      scrollPrev,
+      scrollNext,
+      canScrollPrev,
+      canScrollNext
+    }
+  }, React.createElement("div", {
+    ref: ref,
+    onKeyDownCapture: handleKeyDown,
+    className: cn('relative', className),
+    role: "region",
+    "aria-roledescription": "carousel",
+    ...props
+  }, children));
+});
+Carousel.displayName = 'Carousel';
+const CarouselContent = React.forwardRef(({
+  className,
+  ...props
+}, ref) => {
+  const {
+    carouselRef,
+    orientation
+  } = useCarousel();
+  return React.createElement("div", {
+    ref: carouselRef,
+    className: "overflow-hidden"
+  }, React.createElement("div", {
+    ref: ref,
+    className: cn('flex', orientation === 'horizontal' ? '-ml-4' : '-mt-4 flex-col', className),
+    ...props
+  }));
+});
+CarouselContent.displayName = 'CarouselContent';
+const CarouselItem = React.forwardRef(({
+  className,
+  ...props
+}, ref) => {
+  const {
+    orientation
+  } = useCarousel();
+  return React.createElement("div", {
+    ref: ref,
+    role: "group",
+    "aria-roledescription": "slide",
+    className: cn('min-w-0 shrink-0 grow-0 basis-full', orientation === 'horizontal' ? 'pl-4' : 'pt-4', className),
+    ...props
+  });
+});
+CarouselItem.displayName = 'CarouselItem';
+const CarouselPrevious = React.forwardRef(({
+  className,
+  variant = 'outline',
+  size = 'icon',
+  ...props
+}, ref) => {
+  const {
+    orientation,
+    scrollPrev,
+    canScrollPrev
+  } = useCarousel();
+  return React.createElement(Button, {
+    ref: ref,
+    variant: variant,
+    size: size,
+    className: cn('absolute  h-8 w-8 rounded-full', orientation === 'horizontal' ? '-left-12 top-1/2 -translate-y-1/2' : '-top-12 left-1/2 -translate-x-1/2 rotate-90', className),
+    disabled: !canScrollPrev,
+    onClick: scrollPrev,
+    ...props
+  }, React.createElement(ArrowLeft, {
+    className: "h-4 w-4"
+  }), React.createElement("span", {
+    className: "sr-only"
+  }, "Previous slide"));
+});
+CarouselPrevious.displayName = 'CarouselPrevious';
+const CarouselNext = React.forwardRef(({
+  className,
+  variant = 'outline',
+  size = 'icon',
+  ...props
+}, ref) => {
+  const {
+    orientation,
+    scrollNext,
+    canScrollNext
+  } = useCarousel();
+  return React.createElement(Button, {
+    ref: ref,
+    variant: variant,
+    size: size,
+    className: cn('absolute h-8 w-8 rounded-full', orientation === 'horizontal' ? '-right-12 top-1/2 -translate-y-1/2' : '-bottom-12 left-1/2 -translate-x-1/2 rotate-90', className),
+    disabled: !canScrollNext,
+    onClick: scrollNext,
+    ...props
+  }, React.createElement(ArrowRight, {
+    className: "h-4 w-4"
+  }), React.createElement("span", {
+    className: "sr-only"
+  }, "Next slide"));
+});
+CarouselNext.displayName = 'CarouselNext';export{Carousel,CarouselContent,CarouselItem,CarouselNext,CarouselPrevious};//# sourceMappingURL=carousel.js.map

package/lib/shardui/carousel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"carousel.js","sources":["../../src/shardui/carousel.tsx"],"sourcesContent":[null],"names":[],"mappings":"uQAUA,qBAAmB,GAAG,KAAA,CAAA,aAAqB,CAAC,IAAG,CAAA;AAE/C,oBAAkB,GAAG;QACb,OAAG,GAAA,KAAA,CAAA,UAAgB,CAAA,eAAA,CAAA;MACvB,CAAA,OAAU,EAAA;AACV,IAAA,MAAA,IAAA,KAAc,CAAA,gDAA0B,CAAA;;EAE1C,OAAA,OAAA;AAuBF;AA6FA,MAAA,QAAM,GAAA,KAAA,CAAA,UAAe,CAAA,CAAA;AAiBrB,EAAA,WAAA,GAAM,YAAY;AAqBlB,EAAA,IAAA;AA4BA,EAAA,MAAA;AA4BA,EAAA,OAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/shardui/chart.d.ts

@@ -0,0 +1,63 @@
+import * as React from 'react';
+import * as RechartsPrimitive from 'recharts';
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare const ChartContainer: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => React.JSX.Element;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare const ChartTooltipContent: React.ForwardRefExoticComponent<Omit<RechartsPrimitive.DefaultTooltipContentProps<import("recharts/types/component/DefaultTooltipContent").ValueType, import("recharts/types/component/DefaultTooltipContent").NameType> & {
+    accessibilityLayer?: boolean;
+    active?: boolean | undefined;
+    includeHidden?: boolean | undefined;
+    allowEscapeViewBox?: import("recharts/types/util/types").AllowInDimension;
+    animationDuration?: import("recharts/types/util/types").AnimationDuration;
+    animationEasing?: import("recharts/types/util/types").AnimationTiming;
+    content?: import("recharts/types/component/Tooltip").ContentType<import("recharts/types/component/DefaultTooltipContent").ValueType, import("recharts/types/component/DefaultTooltipContent").NameType>;
+    coordinate?: Partial<import("recharts/types/util/types").Coordinate>;
+    cursor?: boolean | React.ReactElement | React.SVGProps<SVGElement>;
+    filterNull?: boolean;
+    defaultIndex?: number;
+    isAnimationActive?: boolean;
+    offset?: number;
+    payloadUniqBy?: import("recharts/types/util/payload/getUniqPayload").UniqueOption<import("recharts/types/component/DefaultTooltipContent").Payload<import("recharts/types/component/DefaultTooltipContent").ValueType, import("recharts/types/component/DefaultTooltipContent").NameType>>;
+    position?: Partial<import("recharts/types/util/types").Coordinate>;
+    reverseDirection?: import("recharts/types/util/types").AllowInDimension;
+    shared?: boolean;
+    trigger?: "hover" | "click";
+    useTranslate3d?: boolean;
+    viewBox?: import("recharts/types/util/types").CartesianViewBox;
+    wrapperStyle?: React.CSSProperties;
+} & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+declare const ChartLegendContent: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & Pick<RechartsPrimitive.LegendProps, "verticalAlign" | "payload"> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle };
+//# sourceMappingURL=chart.d.ts.map

package/lib/shardui/chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart.d.ts","sourceRoot":"","sources":["../../src/shardui/chart.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,iBAAiB,MAAM,UAAU,CAAC;AAK9C,QAAA,MAAM,MAAM;;;CAAwC,CAAC;AAErD,MAAM,MAAM,WAAW,GAAG;KACrB,CAAC,IAAI,MAAM,GAAG;QACX,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;QACxB,IAAI,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;KAC9B,GAAG,CAAC;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG;QAAE,KAAK,CAAC,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,OAAO,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;CAC1G,CAAC;AAkBF,QAAA,MAAM,cAAc;YAGJ,WAAW;cACT,KAAK,CAAC,cAAc,CAAC,OAAO,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,UAAU,CAAC;gDAsB9F,CAAC;AAGH,QAAA,MAAM,UAAU,GAAI,gBAAgB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,sBA2BtE,CAAC;AAEF,QAAA,MAAM,YAAY,kCAA4B,CAAC;AAE/C,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;gBAID,OAAO;oBACH,OAAO;gBACX,MAAM,GAAG,KAAK,GAAG,QAAQ;cAC3B,MAAM;eACL,MAAM;gDAmI5B,CAAC;AAGF,QAAA,MAAM,WAAW,iCAA2B,CAAC;AAE7C,QAAA,MAAM,kBAAkB;eAID,OAAO;cACR,MAAM;gDA6C1B,CAAC;AA6BH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,kBAAkB,EAAE,UAAU,EAAE,CAAC"}

package/lib/shardui/chart.js

@@ -0,0 +1,182 @@
+import*as React from'react';import*as RechartsPrimitive from'recharts';import'../utils/isBrowser/index.js';import {cn}from'../utils/util.js';import'fast-deep-equal/react.js';// Format: { THEME_NAME: CSS_SELECTOR }
+const THEMES = {
+  light: '',
+  dark: '.dark'
+};
+const ChartContext = React.createContext(null);
+function useChart() {
+  const context = React.useContext(ChartContext);
+  if (!context) {
+    throw new Error('useChart must be used within a <ChartContainer />');
+  }
+  return context;
+}
+const ChartContainer = React.forwardRef(({
+  id,
+  className,
+  children,
+  config,
+  ...props
+}, ref) => {
+  const uniqueId = React.useId();
+  const chartId = `chart-${id || uniqueId.replace(/:/g, '')}`;
+  return React.createElement(ChartContext.Provider, {
+    value: {
+      config
+    }
+  }, React.createElement("div", {
+    "data-chart": chartId,
+    ref: ref,
+    className: cn("flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none", className),
+    ...props
+  }, React.createElement(ChartStyle, {
+    id: chartId,
+    config: config
+  }), React.createElement(RechartsPrimitive.ResponsiveContainer, null, children)));
+});
+ChartContainer.displayName = 'Chart';
+const ChartStyle = ({
+  id,
+  config
+}) => {
+  const colorConfig = Object.entries(config).filter(([_, config]) => config.theme || config.color);
+  if (!colorConfig.length) {
+    return null;
+  }
+  return React.createElement("style", {
+    dangerouslySetInnerHTML: {
+      __html: Object.entries(THEMES).map(([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig.map(([key, itemConfig]) => {
+        const color = itemConfig.theme?.[theme] || itemConfig.color;
+        return color ? `  --color-${key}: ${color};` : null;
+      }).join('\n')}
+}
+`).join('\n')
+    }
+  });
+};
+const ChartTooltip = RechartsPrimitive.Tooltip;
+const ChartTooltipContent = React.forwardRef(({
+  active,
+  payload,
+  className,
+  indicator = 'dot',
+  hideLabel = false,
+  hideIndicator = false,
+  label,
+  labelFormatter,
+  labelClassName,
+  formatter,
+  color,
+  nameKey,
+  labelKey
+}, ref) => {
+  const {
+    config
+  } = useChart();
+  const tooltipLabel = React.useMemo(() => {
+    if (hideLabel || !payload?.length) {
+      return null;
+    }
+    const [item] = payload;
+    const key = `${labelKey || item.dataKey || item.name || 'value'}`;
+    const itemConfig = getPayloadConfigFromPayload(config, item, key);
+    const value = !labelKey && typeof label === 'string' ? config[label]?.label || label : itemConfig?.label;
+    if (labelFormatter) {
+      return React.createElement("div", {
+        className: cn('font-medium', labelClassName)
+      }, labelFormatter(value, payload));
+    }
+    if (!value) {
+      return null;
+    }
+    return React.createElement("div", {
+      className: cn('font-medium', labelClassName)
+    }, value);
+  }, [label, labelFormatter, payload, hideLabel, labelClassName, config, labelKey]);
+  if (!active || !payload?.length) {
+    return null;
+  }
+  const nestLabel = payload.length === 1 && indicator !== 'dot';
+  return React.createElement("div", {
+    ref: ref,
+    className: cn('grid min-w-[8rem] items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl', className)
+  }, !nestLabel ? tooltipLabel : null, React.createElement("div", {
+    className: "grid gap-1.5"
+  }, payload.map((item, index) => {
+    const key = `${nameKey || item.name || item.dataKey || 'value'}`;
+    const itemConfig = getPayloadConfigFromPayload(config, item, key);
+    const indicatorColor = color || item.payload.fill || item.color;
+    return React.createElement("div", {
+      key: item.dataKey,
+      className: cn('flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground', indicator === 'dot' && 'items-center')
+    }, formatter && item?.value !== undefined && item.name ? formatter(item.value, item.name, item, index, item.payload) : React.createElement(React.Fragment, null, itemConfig?.icon ? React.createElement(itemConfig.icon, null) : !hideIndicator && React.createElement("div", {
+      className: cn('shrink-0 rounded-[2px] border-[--color-border] bg-[--color-bg]', {
+        'h-2.5 w-2.5': indicator === 'dot',
+        'w-1': indicator === 'line',
+        'w-0 border-[1.5px] border-dashed bg-transparent': indicator === 'dashed',
+        'my-0.5': nestLabel && indicator === 'dashed'
+      }),
+      style: {
+        '--color-bg': indicatorColor,
+        '--color-border': indicatorColor
+      }
+    }), React.createElement("div", {
+      className: cn('flex flex-1 justify-between leading-none', nestLabel ? 'items-end' : 'items-center')
+    }, React.createElement("div", {
+      className: "grid gap-1.5"
+    }, nestLabel ? tooltipLabel : null, React.createElement("span", {
+      className: "text-muted-foreground"
+    }, itemConfig?.label || item.name)), item.value && React.createElement("span", {
+      className: "font-mono font-medium tabular-nums text-foreground"
+    }, item.value.toLocaleString()))));
+  })));
+});
+ChartTooltipContent.displayName = 'ChartTooltip';
+const ChartLegend = RechartsPrimitive.Legend;
+const ChartLegendContent = React.forwardRef(({
+  className,
+  hideIcon = false,
+  payload,
+  verticalAlign = 'bottom',
+  nameKey
+}, ref) => {
+  const {
+    config
+  } = useChart();
+  if (!payload?.length) {
+    return null;
+  }
+  return React.createElement("div", {
+    ref: ref,
+    className: cn('flex items-center justify-center gap-4', verticalAlign === 'top' ? 'pb-3' : 'pt-3', className)
+  }, payload.map(item => {
+    const key = `${nameKey || item.dataKey || 'value'}`;
+    const itemConfig = getPayloadConfigFromPayload(config, item, key);
+    return React.createElement("div", {
+      key: item.value,
+      className: cn('flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground')
+    }, itemConfig?.icon && !hideIcon ? React.createElement(itemConfig.icon, null) : React.createElement("div", {
+      className: "h-2 w-2 shrink-0 rounded-[2px]",
+      style: {
+        backgroundColor: item.color
+      }
+    }), itemConfig?.label);
+  }));
+});
+ChartLegendContent.displayName = 'ChartLegend';
+// Helper to extract item config from a payload.
+function getPayloadConfigFromPayload(config, payload, key) {
+  if (typeof payload !== 'object' || payload === null) {
+    return undefined;
+  }
+  const payloadPayload = 'payload' in payload && typeof payload.payload === 'object' && payload.payload !== null ? payload.payload : undefined;
+  let configLabelKey = key;
+  if (key in payload && typeof payload[key] === 'string') {
+    configLabelKey = payload[key];
+  } else if (payloadPayload && key in payloadPayload && typeof payloadPayload[key] === 'string') {
+    configLabelKey = payloadPayload[key];
+  }
+  return configLabelKey in config ? config[configLabelKey] : config[key];
+}export{ChartContainer,ChartLegend,ChartLegendContent,ChartStyle,ChartTooltip,ChartTooltipContent};//# sourceMappingURL=chart.js.map

package/lib/shardui/chart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart.js","sources":["../../src/shardui/chart.tsx"],"sourcesContent":[null],"names":[],"mappings":";;EAMqD,KAAA,EAAA,EAAA;AAErD,EAAA,IAAM,EAAA;;AAEE,MAAA,YAAQ,GAAK,mBAAW,CAAA,IAAA,CAAA;AACxB,SAAA,QAAO,GAAK;AACf,EAAA,MAAG,OAAC,GAAA,KAAA,CAAA,UAAA,CAAA,YAAA,CAAA;cAAQ,EAAE;UAAQ,IAAM,KAAE,CAAA,mDAAK,CAAA;;SAAO,OAAQ;;AAAmD,MAAC,cAAA,GAAA,KAAA,CAAA,UAAA,CAAA,CAAA;EACzG,EAAA;AAkBF,EAAA;;;;AA6BA,CAAA,EAAA,GAAA,KAAA;QAA0C,QAAO,GAAA,KAAA,CAAA,KAAA,EAAA;QAAC,iBAAmB,EAAA,EAAA,IAAA,QAAA,CAAA,OAAA,CAAA,IAAA,EAAA,EAAA,CAAA,CAAA,CAAA;AAAE,EAAA,OAAA,KAAA,CAAA,aA2BrE,CAAA,YAAA,CAAA,QAAA,EAAA;AAEF,IAAA,KAAA,EAAA;AAEA,MAAA;;;;;;;;;;;;;;;;;;;;;;;oBAIwB,CAAA,OAAO,CAAA,MAAA,CAAA,CAAA,GAAA,CAAA,CAAA,CAAA,KAAA,EAAA,MAAA,CAAA,KAAA;sBACH,EAAA,EAAA,CAAO;iBACX,CAAA,CAAA,CAAA,GAAM,EAAG,UAAQ,CAAA,KAAQ;cAC3B,KAAA,GAAM,UAAA,CAAA,KAAA,GAAA,KAAA,CAAA,IAAA,UAAA,CAAA,KAAA;eACL,KAAA,GAAM,CAAA,UAAA,EAAA,GAAA,CAAA,EAAA,EAAA,KAAA,CAAA,CAAA,CAAA,GAAA,IAAA;;AAsI7B;AAEA,CAAA,CAAA,CAAA,IAAA,CAAA;;;;AA+EA,MAAA,YAAS,GAAA,iBAA4B,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/shardui/checkbox.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };
+//# sourceMappingURL=checkbox.d.ts.map

package/lib/shardui/checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox.d.ts","sourceRoot":"","sources":["../../src/shardui/checkbox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,iBAAiB,MAAM,0BAA0B,CAAC;AAK9D,QAAA,MAAM,QAAQ,iKAgBZ,CAAC;AAGH,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/lib/shardui/checkbox.js

@@ -0,0 +1,13 @@
+import*as React from'react';import*as CheckboxPrimitive from'@radix-ui/react-checkbox';import {Check}from'lucide-react';import'../utils/isBrowser/index.js';import {cn}from'../utils/util.js';import'fast-deep-equal/react.js';const Checkbox = React.forwardRef(({
+  className,
+  ...props
+}, ref) => React.createElement(CheckboxPrimitive.Root, {
+  ref: ref,
+  className: cn('peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground', className),
+  ...props
+}, React.createElement(CheckboxPrimitive.Indicator, {
+  className: cn('flex items-center justify-center text-current')
+}, React.createElement(Check, {
+  className: "h-4 w-4"
+}))));
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;export{Checkbox};//# sourceMappingURL=checkbox.js.map

package/lib/shardui/checkbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/lib/shardui/collapsible.d.ts

@@ -0,0 +1,6 @@
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+declare const Collapsible: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };
+//# sourceMappingURL=collapsible.d.ts.map

package/lib/shardui/collapsible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapsible.d.ts","sourceRoot":"","sources":["../../src/shardui/collapsible.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,oBAAoB,MAAM,6BAA6B,CAAC;AAEpE,QAAA,MAAM,WAAW,kIAA4B,CAAC;AAE9C,QAAA,MAAM,kBAAkB,4IAA0C,CAAC;AAEnE,QAAA,MAAM,kBAAkB,yIAA0C,CAAC;AAEnE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC"}

package/lib/shardui/collapsible.js

@@ -0,0 +1,3 @@
+import*as CollapsiblePrimitive from'@radix-ui/react-collapsible';const Collapsible = CollapsiblePrimitive.Root;
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger;
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent;export{Collapsible,CollapsibleContent,CollapsibleTrigger};//# sourceMappingURL=collapsible.js.map

package/lib/shardui/collapsible.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapsible.js","sources":["../../src/shardui/collapsible.tsx"],"sourcesContent":[null],"names":[],"mappings":"iEAEA,MAAA,WAAM,GAAA,oBAAW,CAAA;AAEjB,MAAA,kBAAM,GAAA,oBAAkB,CAAA;AAExB,MAAA,kBAAM,GAAA,oBAAkB,CAAA"}

package/lib/shardui/command.d.ts

@@ -0,0 +1,83 @@
+import * as React from 'react';
+import { type DialogProps } from '@radix-ui/react-dialog';
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface CommandDialogProps extends DialogProps {
+}
+declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => React.JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.InputHTMLAttributes<HTMLInputElement> | "asChild">, "value" | "type" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "disabled" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };
+//# sourceMappingURL=command.d.ts.map

package/lib/shardui/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/shardui/command.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAO1D,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;sFAYX,CAAC;AAGH,UAAU,kBAAmB,SAAQ,WAAW;CAAG;AAEnD,QAAA,MAAM,aAAa,GAAI,wBAAwB,kBAAkB,sBAUhE,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;0FAehB,CAAC;AAIH,QAAA,MAAM,WAAW;;;;;;;;sFASf,CAAC;AAIH,QAAA,MAAM,YAAY;;;;;;uJAGqF,CAAC;AAIxG,QAAA,MAAM,YAAY;;;;;;;;;;sFAYhB,CAAC;AAIH,QAAA,MAAM,gBAAgB;;;;;;sFAKpB,CAAC;AAGH,QAAA,MAAM,WAAW;;;;;;;;;;;;sFAYf,CAAC;AAIH,QAAA,MAAM,eAAe;8BAA6B,KAAK,CAAC,cAAc,CAAC,eAAe,CAAC;;CAEtF,CAAC;AAGF,OAAO,EACH,OAAO,EACP,aAAa,EACb,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,eAAe,EACf,gBAAgB,GACnB,CAAC"}