@agroshine/ags-web-ui-kit 1.0.0

package/dist/molecules/index.cjs

@@ -0,0 +1,123 @@
+'use strict';
+
+var chunkDZW4GS2T_cjs = require('../chunk-DZW4GS2T.cjs');
+require('../chunk-FOA46NSG.cjs');
+require('../chunk-E3BTK736.cjs');
+var chunk7R6OXNES_cjs = require('../chunk-7R6OXNES.cjs');
+require('../chunk-2KRMLIJQ.cjs');
+require('../chunk-2TBYPKQ3.cjs');
+require('../chunk-XX4CBCEB.cjs');
+require('../chunk-A3A7PJWG.cjs');
+
+
+
+Object.defineProperty(exports, "Alert", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Alert; }
+});
+Object.defineProperty(exports, "Breadcrumb", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Breadcrumb; }
+});
+Object.defineProperty(exports, "Card", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Card; }
+});
+Object.defineProperty(exports, "Column", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Column_default; }
+});
+Object.defineProperty(exports, "DeleteModal", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.DeleteModal_default; }
+});
+Object.defineProperty(exports, "Drawer", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Drawer_default; }
+});
+Object.defineProperty(exports, "Empty", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Empty; }
+});
+Object.defineProperty(exports, "HoverCard", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.HoverCard; }
+});
+Object.defineProperty(exports, "List", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.List; }
+});
+Object.defineProperty(exports, "Modal", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Modal_default; }
+});
+Object.defineProperty(exports, "Popconfirm", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Popconfirm; }
+});
+Object.defineProperty(exports, "Popover", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Popover; }
+});
+Object.defineProperty(exports, "Segmented", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Segmented; }
+});
+Object.defineProperty(exports, "Statistic", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Statistic; }
+});
+Object.defineProperty(exports, "Step", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Step; }
+});
+Object.defineProperty(exports, "Steps", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Steps; }
+});
+Object.defineProperty(exports, "Table", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Table_default; }
+});
+Object.defineProperty(exports, "TablePagination", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.TablePagination; }
+});
+Object.defineProperty(exports, "Tabs", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Tabs; }
+});
+Object.defineProperty(exports, "Timeline", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Timeline; }
+});
+Object.defineProperty(exports, "Tooltip", {
+  enumerable: true,
+  get: function () { return chunkDZW4GS2T_cjs.Tooltip; }
+});
+Object.defineProperty(exports, "CardContent", {
+  enumerable: true,
+  get: function () { return chunk7R6OXNES_cjs.CardContent; }
+});
+Object.defineProperty(exports, "CardDescription", {
+  enumerable: true,
+  get: function () { return chunk7R6OXNES_cjs.CardDescription; }
+});
+Object.defineProperty(exports, "CardFooter", {
+  enumerable: true,
+  get: function () { return chunk7R6OXNES_cjs.CardFooter; }
+});
+Object.defineProperty(exports, "CardHeader", {
+  enumerable: true,
+  get: function () { return chunk7R6OXNES_cjs.CardHeader; }
+});
+Object.defineProperty(exports, "CardTitle", {
+  enumerable: true,
+  get: function () { return chunk7R6OXNES_cjs.CardTitle; }
+});
+Object.defineProperty(exports, "TooltipProvider", {
+  enumerable: true,
+  get: function () { return chunk7R6OXNES_cjs.TooltipProvider; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/molecules/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/molecules/index.d.cts

@@ -0,0 +1,449 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode, HTMLAttributes, FC, ForwardRefExoticComponent, RefAttributes } from 'react';
+export { a as CardContent, b as CardDescription, c as CardFooter, d as CardHeader, e as CardTitle, g as TooltipProvider } from '../tooltip-Bl2ZTtfg.cjs';
+import '@radix-ui/react-tooltip';
+
+/**
+ * Variants canon Components.html § "Alert" L1149:
+ *   - `default`     neutral (sin tinte) — bg-background border-border text-foreground
+ *   - `success`     verde · `bg-success-50 border-success-200 text-success-700`
+ *   - `warning`     amber · `bg-warning-50 border-warning-100 text-warning-800`
+ *   - `destructive` rojo  · `bg-destructive/[0.05] border-destructive text-destructive`
+ *
+ * Aliases compat:
+ *   - `info`   → primary-tinted (extensión AgroShine, no en canon)
+ *   - `danger` → alias de `destructive`
+ */
+type AlertVariant = 'default' | 'success' | 'warning' | 'destructive' | 'danger' | 'info';
+interface AlertProps {
+    variant?: AlertVariant;
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: boolean | ReactNode;
+    closable?: boolean;
+    onClose?: () => void;
+    className?: string;
+    children?: ReactNode;
+}
+
+declare const Alert: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface BreadcrumbItem {
+    label: ReactNode;
+    href?: string;
+    icon?: ReactNode;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+    maxItems?: number;
+    className?: string;
+    onItemClick?: (item: BreadcrumbItem, index: number) => void;
+}
+
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<BreadcrumbProps & React$1.RefAttributes<HTMLElement>>;
+
+type CardVariant = 'default' | 'flush' | 'interactive';
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * `default` (canon) → bordes y radius shadcn estándar, sub-componentes con padding.
+     * `flush`           → sin padding interno; los hijos controlan el espacio
+     *                      (ideal para envolver `<Table />`, listas, paneles densos).
+     * `interactive`     → cursor pointer, hover sombreado, focus ring.
+     *                      Cuando se usa con `onClick` se renderiza con `role="button"`.
+     */
+    variant?: CardVariant;
+    asChild?: boolean;
+    children?: ReactNode;
+}
+
+/**
+ * Card AgroShine — wrapper sobre `ui/card` (shadcn primitive).
+ *
+ * Re-exporta los sub-componentes (`CardHeader`, `CardTitle`, `CardDescription`,
+ * `CardContent`, `CardFooter`) para una API completa:
+ *
+ *   <Card variant="interactive" onClick={...}>
+ *     <CardHeader>
+ *       <CardTitle>Aspersión 19-001</CardTitle>
+ *       <CardDescription>FOC · Mancozeb 80 %</CardDescription>
+ *     </CardHeader>
+ *     <CardContent>...</CardContent>
+ *     <CardFooter>...</CardFooter>
+ *   </Card>
+ */
+declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface DrawerProps {
+    visible: boolean;
+    onClose: () => void;
+    title?: string;
+    description?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    placement?: 'left' | 'right' | 'top' | 'bottom';
+    children?: ReactNode;
+    footer?: ReactNode;
+    extra?: React.ReactNode | React.ReactNode[];
+}
+declare const Drawer: FC<DrawerProps>;
+
+interface EmptyProps {
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+    action?: React$1.ReactNode;
+    className?: string;
+}
+/**
+ * Canon Components.html § "Empty" L1747 / CSS L464-468:
+ *   .empty   { padding:48px 20px; text-align:center; color:muted-foreground; }
+ *   .empty .ic { font-size:48px; opacity:0.4; margin-bottom:8px; }
+ *   .empty .t  { font-size:14px; font-weight:500; color:foreground; }
+ *   .empty .s  { font-size:13px; margin-top:4px; }
+ *   .empty .acts { margin-top:14px; gap:8px; justify-content:center; }
+ */
+declare const Empty: React$1.ForwardRefExoticComponent<EmptyProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface HoverCardProps {
+    trigger: React$1.ReactNode;
+    children: React$1.ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    openDelay?: number;
+    closeDelay?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    asChild?: boolean;
+}
+declare const HoverCard: React$1.ForwardRefExoticComponent<HoverCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/** Tipo legacy (admin lo usa). */
+interface IDataSourceListCollapse {
+    key: number;
+    value: string;
+    name?: string;
+    label?: string;
+}
+type ListSize = 'small' | 'default' | 'large';
+/**
+ * API canónica (canon Components.html § "List" L2007).
+ * Uso recomendado declarativo:
+ *
+ *   <List bordered header="..." footer="...">
+ *     <List.Item avatar={<Avatar>CM</Avatar>} title="..." description="..." extra={...} actions={...} />
+ *     ...
+ *   </List>
+ *
+ * Uso legacy con `data + renderItem` también soportado (admin lo usa).
+ */
+interface ListProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Legacy data-driven API. */
+    data?: IDataSourceListCollapse[];
+    renderItem?: (item: IDataSourceListCollapse, index: number) => ReactNode;
+    /** Nuevo: API declarativa con `<List.Item />`. */
+    children?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+    bordered?: boolean;
+    size?: ListSize;
+    /** Legacy. Si > 0 trunca y muestra un item "+N, readMoreLabel". */
+    maxVisibleItems?: number;
+    readMoreLabel?: string;
+    onReadMoreClick?: () => void;
+    className?: string;
+}
+/** Slots de `List.Item` (canon `.list-item`). */
+interface ListItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Slot izquierdo (avatar, ícono, etc.) — `.list-meta` lo aloja primero. */
+    avatar?: ReactNode;
+    /** Título principal del item (`.li-title` — `font: 14px/600 foreground`). */
+    title?: ReactNode;
+    /** Descripción debajo del título (`.li-desc` — `font: 12.5px muted-foreground`). */
+    description?: ReactNode;
+    /** Texto/badge a la derecha (`.list-extra` — `font: 13px muted-foreground`). */
+    extra?: ReactNode;
+    /** Botones/acciones a la derecha (`.list-actions` — gap 6px). */
+    actions?: ReactNode;
+    /** Si no se pasan slots, se renderizan los children como contenido libre. */
+    children?: ReactNode;
+}
+
+/**
+ * Canon `.list-item` (Components.html L570):
+ *   display:flex; align-items:center; gap:14px; padding:14px 16px;
+ *   border-bottom:1px solid border; hover:bg-muted/40
+ *
+ * Estructura: [list-meta (avatar + body[title/desc])] [list-extra] [list-actions]
+ */
+declare const ListItem: React$1.ForwardRefExoticComponent<ListItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type ListComponent = ForwardRefExoticComponent<ListProps & RefAttributes<HTMLDivElement>> & {
+    Item: typeof ListItem;
+};
+declare const List: ListComponent;
+
+interface ModalProps$1 {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    deleteData: () => void;
+}
+declare const DeleteModal: React.FC<ModalProps$1>;
+
+interface ModalProps {
+    visible: boolean;
+    onClose: () => void;
+    title?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '5xl';
+    children?: ReactNode;
+    footer?: ReactNode;
+}
+declare const Modal: React.FC<ModalProps>;
+
+interface PopconfirmProps {
+    title: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    okText?: string;
+    cancelText?: string;
+    okVariant?: 'primary' | 'danger';
+    onConfirm: () => void | Promise<void>;
+    onCancel?: () => void;
+    icon?: React$1.ReactNode;
+    children: React$1.ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    className?: string;
+    asChild?: boolean;
+    disabled?: boolean;
+}
+declare const Popconfirm: React$1.ForwardRefExoticComponent<PopconfirmProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface PopoverProps {
+    trigger: React$1.ReactNode;
+    children: React$1.ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    sideOffset?: number;
+    asChild?: boolean;
+}
+declare const Popover: React$1.ForwardRefExoticComponent<PopoverProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SegmentedOption<T extends string = string> {
+    value: T;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+type SegmentedSize = 'sm' | 'md' | 'lg';
+interface SegmentedProps<T extends string = string> {
+    value: T;
+    onChange: (value: T) => void;
+    options: SegmentedOption<T>[];
+    size?: SegmentedSize;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    className?: string;
+}
+
+declare const Segmented: <T extends string = string>(props: SegmentedProps<T> & {
+    ref?: React$1.ForwardedRef<HTMLDivElement>;
+}) => React$1.ReactElement;
+
+interface StatisticProps {
+    title: React$1.ReactNode;
+    value: number | string;
+    prefix?: React$1.ReactNode;
+    suffix?: React$1.ReactNode;
+    precision?: number;
+    trend?: 'up' | 'down';
+    trendValue?: React$1.ReactNode;
+    loading?: boolean;
+    formatter?: (value: number | string) => string;
+    className?: string;
+    valueClassName?: string;
+}
+declare const Statistic: React$1.ForwardRefExoticComponent<StatisticProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+type StepsDirection = 'horizontal' | 'vertical';
+type StepsSize = 'sm' | 'md' | 'lg';
+interface StepInterface {
+    key: string;
+    title: ReactNode;
+    description?: ReactNode;
+    /** Override automático: si no se pasa, se calcula desde `current`. */
+    status?: StepStatus;
+    /** Override del número en el círculo. */
+    icon?: ReactNode;
+    /** Si está deshabilitado (no clickeable y atenuado). */
+    disabled?: boolean;
+}
+interface StepsProps {
+    items: StepInterface[];
+    /** Índice del paso activo (0-based). */
+    current?: number;
+    /** Callback al clickear un paso. */
+    onChange?: (index: number) => void;
+    direction?: StepsDirection;
+    /** sm=24px, md=28px (canon), lg=36px. */
+    size?: StepsSize;
+    className?: string;
+}
+
+interface StepProps {
+    item: StepInterface;
+    index: number;
+    status: StepStatus;
+    size: StepsSize;
+    clickable: boolean;
+    onSelect?: (index: number) => void;
+}
+declare const Step: React$1.FC<StepProps>;
+
+declare const Steps: React$1.ForwardRefExoticComponent<StepsProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type ColumnProps = {
+    title: React__default.ReactNode;
+    dataIndex?: string;
+    key: string;
+    render?: (value: unknown, record: unknown, rowIndex: number) => React__default.ReactNode;
+    width?: number | string;
+    ellipsis?: boolean;
+    align?: 'left' | 'center' | 'right';
+    /** Enables click-to-sort on this column header. Cycles null → asc → desc → null. */
+    sortable?: boolean;
+};
+declare const Column: React__default.FC<ColumnProps>;
+
+interface PaginationTableProps {
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    initialPage?: number;
+    totalItems?: number;
+    totalPages?: number;
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (page: number, pageSize: number) => void;
+    paginatedData: unknown[];
+    currentPage?: number;
+}
+declare const TablePagination: FC<PaginationTableProps>;
+
+type SortDirection = 'asc' | 'desc' | null;
+interface SortState {
+    key: string | null;
+    direction: SortDirection;
+}
+type Density = 'compact' | 'default' | 'comfortable';
+
+type RecordType = Record<string, unknown>;
+type RowKey = string | number;
+interface TableUIProps<T extends RecordType = RecordType> {
+    dataSource: T[];
+    children: ReactNode;
+    variant?: 'default' | 'striped';
+    density?: Density;
+    pagination?: PaginationTableProps;
+    loading?: boolean;
+    emptyText?: ReactNode;
+    rowKey?: (record: T) => RowKey;
+    ariaLabel?: string;
+    selectedRowKeys?: RowKey[];
+    onRow?: (record: T, rowIndex: number) => {
+        onClick?: () => void;
+        [key: string]: unknown;
+    };
+    expandedRowRender?: (record: T) => ReactNode;
+    bordered?: boolean;
+}
+declare function TableUI<T extends RecordType = RecordType>({ dataSource, children, pagination, loading, variant, density, emptyText, rowKey, ariaLabel, selectedRowKeys, onRow, bordered, }: TableUIProps<T>): React__default.ReactElement;
+
+interface TabItem {
+    key: string;
+    label: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+    icon?: ReactNode;
+}
+type TabsVariant = 'line' | 'card' | 'pill';
+type TabsSize = 'sm' | 'md' | 'lg';
+interface TabsProps {
+    items: TabItem[];
+    defaultValue?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    variant?: TabsVariant;
+    size?: TabsSize;
+    className?: string;
+    listClassName?: string;
+    contentClassName?: string;
+}
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type TimelineItemStatus = 'pending' | 'in-progress' | 'done' | 'error';
+interface TimelineItem {
+    key: string;
+    content: ReactNode;
+    time?: ReactNode;
+    status?: TimelineItemStatus;
+    icon?: ReactNode;
+}
+type TimelineMode = 'left' | 'right' | 'alternate';
+interface TimelineProps {
+    items: TimelineItem[];
+    mode?: TimelineMode;
+    className?: string;
+}
+
+declare const Timeline: React$1.ForwardRefExoticComponent<TimelineProps & React$1.RefAttributes<HTMLUListElement>>;
+
+interface TooltipProps {
+    /** Contenido renderizado dentro del bubble flotante. */
+    content: React$1.ReactNode;
+    /** Elemento que dispara el tooltip al hover/focus. */
+    children: React$1.ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    /** Delay en ms antes de abrir. Default 200ms (canon Components.html). */
+    delayDuration?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Clases extra sobre el `TooltipContent`. */
+    className?: string;
+    /**
+     * Si `true` (default) el trigger usa `asChild` y NO añade un `<button>` extra,
+     * delegando el evento al `children`. Pónlo a `false` sólo si el children
+     * no acepta refs o handlers (texto plano, fragments, etc.).
+     */
+    asChild?: boolean;
+    /**
+     * Si la app ya monta un `<TooltipProvider>` global (recomendado para apps
+     * con muchos tooltips) pasa `withProvider={false}` para evitar montar uno
+     * adicional por instancia. Por defecto `true` para uso "drop-in" cómodo.
+     *
+     * NOTA: cada provider tiene su propio estado de delay/skip-delay. Sin
+     * provider global, el "skip delay" de Radix (segundo tooltip abre sin
+     * espera) no funciona entre instancias.
+     */
+    withProvider?: boolean;
+}
+/**
+ * Tooltip · wrapper de conveniencia sobre `ui/tooltip` (Radix).
+ *
+ * Canon: `Components.html` línea ~1124, CSS `.tooltip*` / `.hcard*`.
+ *
+ * - Para casos puntuales: usa este wrapper tal cual.
+ * - Para apps con MUCHOS tooltips: monta un `<TooltipProvider>` global en el
+ *   root y usa `<Tooltip withProvider={false}>` (o importa primitives desde
+ *   `ui/tooltip` directamente). Eso habilita el comportamiento de skip-delay
+ *   y evita providers redundantes.
+ */
+declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLDivElement>>;
+
+export { Alert, type AlertProps, type AlertVariant, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Card, type CardProps, type CardVariant, Column, type ColumnProps, DeleteModal, type Density, Drawer, Empty, type EmptyProps, HoverCard, type HoverCardProps, List, Modal, type PaginationTableProps, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, Segmented, type SegmentedOption, type SegmentedProps, type SegmentedSize, type SortDirection, type SortState, Statistic, type StatisticProps, Step, type StepInterface, type StepProps, type StepStatus, Steps, type StepsDirection, type StepsProps, type StepsSize, type TabItem, TableUI as Table, TablePagination, Tabs, type TabsProps, type TabsSize, type TabsVariant, Timeline, type TimelineItem, type TimelineItemStatus, type TimelineMode, type TimelineProps, Tooltip, type TooltipProps };