@demokit-ui/demokit 0.1.0

package/dist/kit/components/data-display/data-grid/data-grid-table.js

@@ -0,0 +1,356 @@
+import { jsxs as b, jsx as o, Fragment as x } from "react/jsx-runtime";
+import { Fragment as L } from "react";
+import { Checkbox as m } from "../../form/checkbox/checkbox.js";
+import { useDataGrid as s } from "./data-grid.js";
+import { flexRender as p } from "@tanstack/react-table";
+import { cva as h } from "class-variance-authority";
+import { cn as c } from "../../../../lib/utils.js";
+const w = h("", {
+  variants: {
+    size: {
+      dense: "px-2.5 h-8",
+      default: "px-4"
+    }
+  },
+  defaultVariants: {
+    size: "default"
+  }
+}), f = h("", {
+  variants: {
+    size: {
+      dense: "px-2.5 py-2",
+      default: "px-4 py-3"
+    }
+  },
+  defaultVariants: {
+    size: "default"
+  }
+});
+function y(t) {
+  const e = t.getIsPinned();
+  return {
+    left: e === "left" ? `${t.getStart("left")}px` : void 0,
+    right: e === "right" ? `${t.getAfter("right")}px` : void 0,
+    position: e ? "sticky" : "relative",
+    width: t.getSize(),
+    zIndex: e ? 1 : 0
+  };
+}
+function R({ children: t }) {
+  const { props: e } = s();
+  return /* @__PURE__ */ o(
+    "table",
+    {
+      "data-slot": "data-grid-table",
+      className: c(
+        "w-full align-middle caption-bottom text-left rtl:text-right text-foreground font-normal text-sm",
+        !e.tableLayout?.columnsDraggable && "border-separate border-spacing-0",
+        e.tableLayout?.width === "fixed" ? "table-fixed" : "table-auto",
+        e.tableClassNames?.base
+      ),
+      children: t
+    }
+  );
+}
+function N({ children: t }) {
+  const { props: e } = s();
+  return /* @__PURE__ */ o(
+    "thead",
+    {
+      className: c(
+        e.tableClassNames?.header,
+        e.tableLayout?.headerSticky && e.tableClassNames?.headerSticky
+      ),
+      children: t
+    }
+  );
+}
+function S({
+  children: t,
+  headerGroup: e
+}) {
+  const { props: l } = s();
+  return /* @__PURE__ */ o(
+    "tr",
+    {
+      className: c(
+        "bg-muted/40",
+        l.tableLayout?.headerBorder && "[&>th]:border-b",
+        l.tableLayout?.cellBorder && "[&_>:last-child]:border-e-0",
+        l.tableLayout?.stripped && "bg-transparent",
+        l.tableLayout?.headerBackground === !1 && "bg-transparent",
+        l.tableClassNames?.headerRow
+      ),
+      children: t
+    },
+    e.id
+  );
+}
+function z({
+  children: t,
+  header: e,
+  dndRef: l,
+  dndStyle: d
+}) {
+  const { props: a } = s(), { column: n } = e, r = n.getIsPinned(), i = r === "left" && n.getIsLastColumn("left"), u = r === "right" && n.getIsFirstColumn("right"), g = w({
+    size: a.tableLayout?.dense ? "dense" : "default"
+  });
+  return /* @__PURE__ */ o(
+    "th",
+    {
+      ref: l,
+      style: {
+        ...a.tableLayout?.width === "fixed" && {
+          width: `${e.getSize()}px`
+        },
+        ...a.tableLayout?.columnsPinnable && n.getCanPin() && y(n),
+        ...d || null
+      },
+      "data-pinned": r || void 0,
+      "data-last-col": i ? "left" : u ? "right" : void 0,
+      className: c(
+        "relative h-10 text-left rtl:text-right align-middle font-normal text-accent-foreground [&:has([role=checkbox])]:pe-0",
+        g,
+        a.tableLayout?.cellBorder && "border-e",
+        a.tableLayout?.columnsResizable && n.getCanResize() && "truncate",
+        a.tableLayout?.columnsPinnable && n.getCanPin() && "[&:not([data-pinned]):has(+[data-pinned])_div.cursor-col-resize:last-child]:opacity-0 [&[data-last-col=left]_div.cursor-col-resize:last-child]:opacity-0 [&[data-pinned=left][data-last-col=left]]:border-e! [&[data-pinned=right]:last-child_div.cursor-col-resize:last-child]:opacity-0 [&[data-pinned=right][data-last-col=right]]:border-s! [&[data-pinned][data-last-col]]:border-border data-pinned:bg-muted/90 data-pinned:backdrop-blur-xs",
+        e.column.columnDef.meta?.headerClassName,
+        n.getIndex() === 0 || n.getIndex() === e.headerGroup.headers.length - 1 ? a.tableClassNames?.edgeCell : ""
+      ),
+      children: t
+    },
+    e.id
+  );
+}
+function v({ header: t }) {
+  const { column: e } = t;
+  return /* @__PURE__ */ o(
+    "div",
+    {
+      onDoubleClick: () => e.resetSize(),
+      onMouseDown: t.getResizeHandler(),
+      onTouchStart: t.getResizeHandler(),
+      className: "absolute top-0 h-full w-4 cursor-col-resize user-select-none touch-none -end-2 z-10 flex justify-center before:absolute before:w-px before:inset-y-0 before:bg-border before:-translate-x-px"
+    }
+  );
+}
+function D() {
+  return /* @__PURE__ */ o("tbody", { "aria-hidden": "true", className: "h-2" });
+}
+function k({ children: t }) {
+  const { props: e } = s();
+  return /* @__PURE__ */ o(
+    "tbody",
+    {
+      className: c(
+        "[&_tr:last-child]:border-0",
+        e.tableLayout?.rowRounded && "[&_td:first-child]:rounded-s-lg [&_td:last-child]:rounded-e-lg",
+        e.tableClassNames?.body
+      ),
+      children: t
+    }
+  );
+}
+function P({ children: t }) {
+  const { table: e, props: l } = s();
+  return /* @__PURE__ */ o(
+    "tr",
+    {
+      className: c(
+        "hover:bg-muted/40 data-[state=selected]:bg-muted/50",
+        l.onRowClick && "cursor-pointer",
+        !l.tableLayout?.stripped && l.tableLayout?.rowBorder && "border-b border-border [&:not(:last-child)>td]:border-b",
+        l.tableLayout?.cellBorder && "[&_>:last-child]:border-e-0",
+        l.tableLayout?.stripped && "odd:bg-muted/90 hover:bg-transparent odd:hover:bg-muted",
+        e.options.enableRowSelection && "[&_>:first-child]:relative",
+        l.tableClassNames?.bodyRow
+      ),
+      children: t
+    }
+  );
+}
+function B({ children: t, column: e }) {
+  const { props: l, table: d } = s(), a = f({
+    size: l.tableLayout?.dense ? "dense" : "default"
+  });
+  return /* @__PURE__ */ o(
+    "td",
+    {
+      className: c(
+        "align-middle",
+        a,
+        l.tableLayout?.cellBorder && "border-e",
+        l.tableLayout?.columnsResizable && e.getCanResize() && "truncate",
+        e.columnDef.meta?.cellClassName,
+        l.tableLayout?.columnsPinnable && e.getCanPin() && '[&[data-pinned=left][data-last-col=left]]:border-e! [&[data-pinned=right][data-last-col=right]]:border-s! [&[data-pinned][data-last-col]]:border-border data-pinned:bg-background/90 data-pinned:backdrop-blur-xs"',
+        e.getIndex() === 0 || e.getIndex() === d.getVisibleFlatColumns().length - 1 ? l.tableClassNames?.edgeCell : ""
+      ),
+      children: t
+    }
+  );
+}
+function I({
+  children: t,
+  row: e,
+  dndRef: l,
+  dndStyle: d
+}) {
+  const { props: a, table: n } = s();
+  return /* @__PURE__ */ o(
+    "tr",
+    {
+      ref: l,
+      style: { ...d || null },
+      "data-state": n.options.enableRowSelection && e.getIsSelected() ? "selected" : void 0,
+      onClick: () => a.onRowClick && a.onRowClick(e.original),
+      className: c(
+        "hover:bg-muted/40 data-[state=selected]:bg-muted/50",
+        a.onRowClick && "cursor-pointer",
+        !a.tableLayout?.stripped && a.tableLayout?.rowBorder && "border-b border-border [&:not(:last-child)>td]:border-b",
+        a.tableLayout?.cellBorder && "[&_>:last-child]:border-e-0",
+        a.tableLayout?.stripped && "odd:bg-muted/90 hover:bg-transparent odd:hover:bg-muted",
+        n.options.enableRowSelection && "[&_>:first-child]:relative",
+        a.tableClassNames?.bodyRow
+      ),
+      children: t
+    }
+  );
+}
+function G({ row: t }) {
+  const { props: e, table: l } = s();
+  return /* @__PURE__ */ o("tr", { className: c(e.tableLayout?.rowBorder && "[&:not(:last-child)>td]:border-b"), children: /* @__PURE__ */ o("td", { colSpan: t.getVisibleCells().length, children: l.getAllColumns().find((d) => d.columnDef.meta?.expandedContent)?.columnDef.meta?.expandedContent?.(t.original) }) });
+}
+function T({
+  children: t,
+  cell: e,
+  dndRef: l,
+  dndStyle: d
+}) {
+  const { props: a } = s(), { column: n, row: r } = e, i = n.getIsPinned(), u = i === "left" && n.getIsLastColumn("left"), g = i === "right" && n.getIsFirstColumn("right"), C = f({
+    size: a.tableLayout?.dense ? "dense" : "default"
+  });
+  return /* @__PURE__ */ o(
+    "td",
+    {
+      ref: l,
+      ...a.tableLayout?.columnsDraggable && !i ? { cell: e } : {},
+      style: {
+        ...a.tableLayout?.columnsPinnable && n.getCanPin() && y(n),
+        ...d || null
+      },
+      "data-pinned": i || void 0,
+      "data-last-col": u ? "left" : g ? "right" : void 0,
+      className: c(
+        "align-middle",
+        C,
+        a.tableLayout?.cellBorder && "border-e",
+        a.tableLayout?.columnsResizable && n.getCanResize() && "truncate",
+        e.column.columnDef.meta?.cellClassName,
+        a.tableLayout?.columnsPinnable && n.getCanPin() && '[&[data-pinned=left][data-last-col=left]]:border-e! [&[data-pinned=right][data-last-col=right]]:border-s! [&[data-pinned][data-last-col]]:border-border data-pinned:bg-background/90 data-pinned:backdrop-blur-xs"',
+        n.getIndex() === 0 || n.getIndex() === r.getVisibleCells().length - 1 ? a.tableClassNames?.edgeCell : ""
+      ),
+      children: t
+    },
+    e.id
+  );
+}
+function _() {
+  const { table: t, props: e } = s(), l = t.getAllColumns().length;
+  return /* @__PURE__ */ o("tr", { children: /* @__PURE__ */ o("td", { colSpan: l, className: "text-center text-muted-foreground py-6", children: e.emptyMessage || "No data available" }) });
+}
+function E() {
+  const { props: t } = s();
+  return /* @__PURE__ */ o("div", { className: "absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2", children: /* @__PURE__ */ b("div", { className: "text-muted-foreground bg-card  flex items-center gap-2 px-4 py-2 font-medium leading-none text-sm border shadow-xs rounded-md", children: [
+    /* @__PURE__ */ b(
+      "svg",
+      {
+        className: "animate-spin -ml-1 h-5 w-5 text-muted-foreground",
+        xmlns: "http://www.w3.org/2000/svg",
+        fill: "none",
+        viewBox: "0 0 24 24",
+        children: [
+          /* @__PURE__ */ o("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "3" }),
+          /* @__PURE__ */ o(
+            "path",
+            {
+              className: "opacity-75",
+              fill: "currentColor",
+              d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+            }
+          )
+        ]
+      }
+    ),
+    t.loadingMessage || "Loading..."
+  ] }) });
+}
+function W({ row: t, size: e }) {
+  return /* @__PURE__ */ b(x, { children: [
+    /* @__PURE__ */ o(
+      "div",
+      {
+        className: c("hidden absolute top-0 bottom-0 start-0 w-[2px] bg-primary", t.getIsSelected() && "block")
+      }
+    ),
+    /* @__PURE__ */ o(
+      m,
+      {
+        checked: t.getIsSelected(),
+        onCheckedChange: (l) => t.toggleSelected(!!l),
+        "aria-label": "Select row",
+        size: e ?? "sm",
+        className: "align-[inherit]"
+      }
+    )
+  ] });
+}
+function q({ size: t }) {
+  const { table: e, recordCount: l, isLoading: d } = s();
+  return /* @__PURE__ */ o(
+    m,
+    {
+      checked: e.getIsAllPageRowsSelected() || e.getIsSomePageRowsSelected() && "indeterminate",
+      disabled: d || l === 0,
+      onCheckedChange: (a) => e.toggleAllPageRowsSelected(!!a),
+      "aria-label": "Select all",
+      size: t,
+      className: "align-[inherit]"
+    }
+  );
+}
+function J() {
+  const { table: t, isLoading: e, props: l } = s(), d = t.getState().pagination;
+  return /* @__PURE__ */ b(R, { children: [
+    /* @__PURE__ */ o(N, { children: t.getHeaderGroups().map((a, n) => /* @__PURE__ */ o(S, { headerGroup: a, children: a.headers.map((r, i) => {
+      const { column: u } = r;
+      return /* @__PURE__ */ b(z, { header: r, children: [
+        r.isPlaceholder ? null : p(r.column.columnDef.header, r.getContext()),
+        l.tableLayout?.columnsResizable && u.getCanResize() && /* @__PURE__ */ o(v, { header: r })
+      ] }, i);
+    }) }, n)) }),
+    (l.tableLayout?.stripped || !l.tableLayout?.rowBorder) && /* @__PURE__ */ o(D, {}),
+    /* @__PURE__ */ o(k, { children: l.loadingMode === "skeleton" && e && d?.pageSize ? Array.from({ length: d.pageSize }).map((a, n) => /* @__PURE__ */ o(P, { children: t.getVisibleFlatColumns().map((r, i) => /* @__PURE__ */ o(B, { column: r, children: r.columnDef.meta?.skeleton }, i)) }, n)) : t.getRowModel().rows.length ? t.getRowModel().rows.map((a, n) => /* @__PURE__ */ b(L, { children: [
+      /* @__PURE__ */ o(I, { row: a, children: a.getVisibleCells().map((r, i) => /* @__PURE__ */ o(T, { cell: r, children: p(r.column.columnDef.cell, r.getContext()) }, i)) }, n),
+      a.getIsExpanded() && /* @__PURE__ */ o(G, { row: a })
+    ] }, a.id)) : /* @__PURE__ */ o(_, {}) })
+  ] });
+}
+export {
+  J as DataGridTable,
+  R as DataGridTableBase,
+  k as DataGridTableBody,
+  I as DataGridTableBodyRow,
+  T as DataGridTableBodyRowCell,
+  G as DataGridTableBodyRowExpandded,
+  P as DataGridTableBodyRowSkeleton,
+  B as DataGridTableBodyRowSkeletonCell,
+  _ as DataGridTableEmpty,
+  N as DataGridTableHead,
+  S as DataGridTableHeadRow,
+  z as DataGridTableHeadRowCell,
+  v as DataGridTableHeadRowCellResize,
+  E as DataGridTableLoader,
+  W as DataGridTableRowSelect,
+  q as DataGridTableRowSelectAll,
+  D as DataGridTableRowSpacer
+};

package/dist/kit/components/data-display/data-grid/data-grid.d.ts

@@ -0,0 +1,87 @@
+import { ReactNode } from 'react';
+import { ColumnFiltersState, RowData, SortingState, Table } from '@tanstack/react-table';
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        headerTitle?: string;
+        headerClassName?: string;
+        cellClassName?: string;
+        skeleton?: ReactNode;
+        expandedContent?: (row: TData) => ReactNode;
+    }
+}
+export type DataGridApiFetchParams = {
+    pageIndex: number;
+    pageSize: number;
+    sorting?: SortingState;
+    filters?: ColumnFiltersState;
+    searchQuery?: string;
+};
+export type DataGridApiResponse<T> = {
+    data: T[];
+    empty: boolean;
+    pagination: {
+        total: number;
+        page: number;
+    };
+};
+export interface DataGridContextProps<TData extends object> {
+    props: DataGridProps<TData>;
+    table: Table<TData>;
+    recordCount: number;
+    isLoading: boolean;
+}
+export type DataGridRequestParams = {
+    pageIndex: number;
+    pageSize: number;
+    sorting?: SortingState;
+    columnFilters?: ColumnFiltersState;
+};
+export interface DataGridProps<TData extends object> {
+    className?: string;
+    table?: Table<TData>;
+    recordCount: number;
+    children?: ReactNode;
+    onRowClick?: (row: TData) => void;
+    isLoading?: boolean;
+    loadingMode?: 'skeleton' | 'spinner';
+    loadingMessage?: ReactNode | string;
+    emptyMessage?: ReactNode | string;
+    tableLayout?: {
+        dense?: boolean;
+        cellBorder?: boolean;
+        rowBorder?: boolean;
+        rowRounded?: boolean;
+        stripped?: boolean;
+        headerBackground?: boolean;
+        headerBorder?: boolean;
+        headerSticky?: boolean;
+        width?: 'auto' | 'fixed';
+        columnsVisibility?: boolean;
+        columnsResizable?: boolean;
+        columnsPinnable?: boolean;
+        columnsMovable?: boolean;
+        columnsDraggable?: boolean;
+        rowsDraggable?: boolean;
+    };
+    tableClassNames?: {
+        base?: string;
+        header?: string;
+        headerRow?: string;
+        headerSticky?: string;
+        body?: string;
+        bodyRow?: string;
+        footer?: string;
+        edgeCell?: string;
+    };
+}
+declare function useDataGrid(): DataGridContextProps<any>;
+declare function DataGridProvider<TData extends object>({ children, table, ...props }: DataGridProps<TData> & {
+    table: Table<TData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DataGrid<TData extends object>({ children, table, ...props }: DataGridProps<TData>): import("react/jsx-runtime").JSX.Element;
+declare function DataGridContainer({ children, className, border, }: {
+    children: ReactNode;
+    className?: string;
+    border?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { useDataGrid, DataGridProvider, DataGrid, DataGridContainer };

package/dist/kit/components/data-display/data-grid/data-grid.js

@@ -0,0 +1,87 @@
+import { jsx as o } from "react/jsx-runtime";
+import { useContext as l, createContext as i } from "react";
+import { cn as n } from "../../../../lib/utils.js";
+const d = i(void 0);
+function m() {
+  const r = l(d);
+  if (!r)
+    throw new Error("useDataGrid must be used within a DataGridProvider");
+  return r;
+}
+function u({
+  children: r,
+  table: a,
+  ...e
+}) {
+  return /* @__PURE__ */ o(
+    d.Provider,
+    {
+      value: {
+        props: e,
+        table: a,
+        recordCount: e.recordCount,
+        isLoading: e.isLoading || !1
+      },
+      children: r
+    }
+  );
+}
+function g({ children: r, table: a, ...e }) {
+  const t = {
+    loadingMode: "skeleton",
+    tableLayout: {
+      dense: !1,
+      cellBorder: !1,
+      rowBorder: !0,
+      rowRounded: !1,
+      stripped: !1,
+      headerSticky: !1,
+      headerBackground: !0,
+      headerBorder: !0,
+      width: "fixed",
+      columnsVisibility: !1,
+      columnsResizable: !1,
+      columnsPinnable: !1,
+      columnsMovable: !1,
+      columnsDraggable: !1,
+      rowsDraggable: !1
+    },
+    tableClassNames: {
+      base: "",
+      header: "",
+      headerRow: "",
+      headerSticky: "sticky top-0 z-10 bg-background/90 backdrop-blur-xs",
+      body: "",
+      bodyRow: "",
+      footer: "",
+      edgeCell: ""
+    }
+  }, s = {
+    ...t,
+    ...e,
+    tableLayout: {
+      ...t.tableLayout,
+      ...e.tableLayout || {}
+    },
+    tableClassNames: {
+      ...t.tableClassNames,
+      ...e.tableClassNames || {}
+    }
+  };
+  if (!a)
+    throw new Error('DataGrid requires a "table" prop');
+  return /* @__PURE__ */ o(u, { table: a, ...s, children: r });
+}
+function w({
+  children: r,
+  className: a,
+  border: e = !0
+}) {
+  return /* @__PURE__ */ o("div", { "data-slot": "data-grid", className: n("grid w-full", e && "border border-border rounded-lg", a), children: r });
+}
+export {
+  g as DataGrid,
+  w as DataGridContainer,
+  u as DataGridProvider,
+  m as useDataGrid
+};

package/dist/kit/components/data-display/kbd/kbd.d.ts

@@ -0,0 +1,8 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const kbdVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "xs" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Kbd({ className, variant, size, ...props }: React.ComponentProps<'kbd'> & VariantProps<typeof kbdVariants>): import("react/jsx-runtime").JSX.Element;
+export { Kbd, kbdVariants };

package/dist/kit/components/data-display/kbd/kbd.js

@@ -0,0 +1,27 @@
+import { jsx as i } from "react/jsx-runtime";
+import { cn as o } from "../../../../lib/utils.js";
+import { cva as a } from "class-variance-authority";
+const d = a("inline-flex items-center justify-center font-mono rounded-md", {
+  variants: {
+    variant: {
+      default: "bg-accent border border-border text-accent-foreground",
+      outline: "text-accent-foreground border border-input"
+    },
+    size: {
+      md: "h-7 min-w-7 px-1.5 text-xs [&_svg]:size-3.5",
+      sm: "h-6 min-w-6 px-1 text-[0.75rem] leading-[0.75rem] [&_svg]:size-3",
+      xs: "h-5 min-w-5 px-1 text-[0.6875rem] leading-[0.75rem] [&_svg]:size-3"
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    size: "md"
+  }
+});
+function x({ className: e, variant: t, size: r, ...n }) {
+  return /* @__PURE__ */ i("kbd", { "data-slot": "kbd", className: o(d({ variant: t, size: r }), e), ...n });
+}
+export {
+  x as Kbd,
+  d as kbdVariants
+};

package/dist/kit/components/data-display/money-amount/money-amount.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+type MoneyUnit = 'auto' | 'yuan' | 'wan' | 'yi';
+type ResolvedMoneyUnit = Exclude<MoneyUnit, 'auto'>;
+declare const MONEY_UNIT_LABELS: Record<ResolvedMoneyUnit, string>;
+export type FormattedMoneyAmount = {
+    raw: number;
+    value: number;
+    displayValue: string;
+    unit: string;
+    unitKey: ResolvedMoneyUnit;
+    text: string;
+};
+export type FormatMoneyAmountOptions = {
+    unit?: MoneyUnit;
+    precision?: number;
+    keepTrailingZeros?: boolean;
+    locale?: string;
+};
+export type MoneyAmountProps = Omit<React.ComponentProps<'span'>, 'children'> & FormatMoneyAmountOptions & {
+    value: number | string | null | undefined;
+    fallback?: React.ReactNode;
+    valueClassName?: string;
+    unitClassName?: string;
+};
+declare function formatMoneyAmount(value: number | string | null | undefined, { unit, precision, keepTrailingZeros, locale, }?: FormatMoneyAmountOptions): FormattedMoneyAmount | null;
+declare function MoneyAmount({ value, unit, precision, keepTrailingZeros, locale, fallback, className, valueClassName, unitClassName, ...props }: MoneyAmountProps): import("react/jsx-runtime").JSX.Element;
+export { MoneyAmount, formatMoneyAmount, MONEY_UNIT_LABELS };

package/dist/kit/components/data-display/money-amount/money-amount.js

@@ -0,0 +1,91 @@
+import { jsx as f, jsxs as d } from "react/jsx-runtime";
+import { cn as l } from "../../../../lib/utils.js";
+const N = {
+  yuan: "元",
+  wan: "万元",
+  yi: "亿元"
+}, y = {
+  yuan: 1,
+  wan: 1e4,
+  yi: 1e8
+};
+function p(n) {
+  if (typeof n == "number")
+    return Number.isFinite(n) ? n : null;
+  if (typeof n != "string")
+    return null;
+  const e = n.replace(/[,\s¥￥]/g, ""), t = Number(e);
+  return Number.isFinite(t) ? t : null;
+}
+function b(n, e) {
+  if (e !== "auto")
+    return e;
+  const t = Math.abs(n);
+  return t >= y.yi ? "yi" : t >= y.wan ? "wan" : "yuan";
+}
+function x(n, {
+  unit: e = "auto",
+  precision: t = 2,
+  keepTrailingZeros: m = !1,
+  locale: c = "zh-CN"
+} = {}) {
+  const a = p(n);
+  if (a === null)
+    return null;
+  const o = b(a, e), u = a / y[o], i = new Intl.NumberFormat(c, {
+    minimumFractionDigits: m ? t : 0,
+    maximumFractionDigits: t
+  }).format(u), r = N[o];
+  return {
+    raw: a,
+    value: u,
+    displayValue: i,
+    unit: r,
+    unitKey: o,
+    text: `${i}${r}`
+  };
+}
+function M({
+  value: n,
+  unit: e = "auto",
+  precision: t = 2,
+  keepTrailingZeros: m = !1,
+  locale: c = "zh-CN",
+  fallback: a = "-",
+  className: o,
+  valueClassName: u,
+  unitClassName: i,
+  ...r
+}) {
+  const s = x(n, {
+    unit: e,
+    precision: t,
+    keepTrailingZeros: m,
+    locale: c
+  });
+  return s ? /* @__PURE__ */ d(
+    "span",
+    {
+      "data-slot": "money-amount",
+      "aria-label": s.text,
+      className: l("inline-flex items-baseline gap-1 tabular-nums", o),
+      ...r,
+      children: [
+        /* @__PURE__ */ f("span", { "data-slot": "money-amount-value", className: l("font-mono", u), children: s.displayValue }),
+        /* @__PURE__ */ f(
+          "span",
+          {
+            "data-slot": "money-amount-unit",
+            className: l("text-[0.68em] font-normal text-muted-foreground", i),
+            children: s.unit
+          }
+        )
+      ]
+    }
+  ) : /* @__PURE__ */ f("span", { "data-slot": "money-amount", className: l("text-muted-foreground", o), ...r, children: a });
+}
+export {
+  N as MONEY_UNIT_LABELS,
+  M as MoneyAmount,
+  x as formatMoneyAmount
+};

package/dist/kit/components/data-display/progress/progress.d.ts

@@ -0,0 +1,6 @@
+import { Progress as ProgressPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Progress({ className, indicatorClassName, value, ...props }: React.ComponentProps<typeof ProgressPrimitive.Root> & {
+    indicatorClassName?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { Progress };