@ahoo-wang/fetcher-viewer 3.1.8 → 3.2.0

package/dist/registry/componentRegistry.d.ts

@@ -0,0 +1,100 @@
+import { FunctionComponent } from 'react';
+/**
+ * Interface for objects that have a type property.
+ * This is used to identify components or other typed entities in the registry.
+ *
+ * @template Type - The type of the type property, defaults to string.
+ */
+export interface TypeCapable<Type = string> {
+    /**
+     * The type identifier for this object.
+     */
+    type: Type;
+}
+/**
+ * A registry class for storing and retrieving React components by type.
+ * This allows dynamic component resolution based on type identifiers, useful for
+ * rendering different components based on data types or configurations.
+ *
+ * @template Type - The type used as keys in the registry (e.g., string, number).
+ * @template Props - The props type that all registered components must accept.
+ */
+export declare class TypedComponentRegistry<Type, Props> {
+    private readonly registry;
+    /**
+     * Gets an array of all registered types in the registry.
+     *
+     * @returns An array containing all type keys currently registered.
+     */
+    get types(): Type[];
+    /**
+     * Gets an array of all type-component pairs in the registry.
+     *
+     * @returns An array of tuples containing [type, component] pairs.
+     */
+    get entries(): [Type, FunctionComponent<Props>][];
+    /**
+     * Gets the number of registered components in the registry.
+     *
+     * @returns The total count of registered components.
+     */
+    get size(): number;
+    /**
+     * Checks if a component is registered for the given type.
+     *
+     * @param {Type} type - The type to check for registration.
+     * @returns {boolean} True if a component is registered for the type, false otherwise.
+     */
+    has(type: Type): boolean;
+    /**
+     * Removes all registered components from the registry.
+     */
+    clear(): void;
+    /**
+     * Registers a React component for a specific type.
+     * Each type can only have one component registered.
+     *
+     * @param {Type} type - The type identifier for the component.
+     * @param {FunctionComponent<Props>} component - The React functional component to register.
+     * @throws {Error} If a component is already registered for the given type.
+     *
+     * @example
+     * ```typescript
+     * const registry = new TypedComponentRegistry<string, { value: string }>();
+     * registry.register('text', ({ value }) => <span>{value}</span>);
+     * ```
+     */
+    register(type: Type, component: FunctionComponent<Props>): void;
+    /**
+     * Unregisters the component for the given type.
+     * If no component is registered for the type, this operation does nothing.
+     *
+     * @param {Type} type - The type identifier to unregister.
+     */
+    unregister(type: Type): void;
+    /**
+     * Retrieves the component registered for the given type.
+     *
+     * @param {Type} type - The type identifier to look up.
+     * @returns {FunctionComponent<Props> | undefined} The registered React component, or undefined if not found.
+     */
+    get(type: Type): FunctionComponent<Props> | undefined;
+    /**
+     * Creates a new TypedComponentRegistry instance and optionally registers initial components.
+     *
+     * @template Type - The type used as keys.
+     * @template Props - The props type for components.
+     * @param {Array<[Type, FunctionComponent<Props>]>} [components=[]] - An optional array of [type, component] pairs to register initially.
+     * @returns {TypedComponentRegistry<Type, Props>} A new TypedComponentRegistry instance with the specified components registered.
+     *
+     * @example
+     * ```typescript
+     * const registry = TypedComponentRegistry.create([
+     *   ['text', ({ value }) => <span>{value}</span>],
+     *   ['number', ({ value }) => <strong>{value}</strong>]
+     * ]);
+     * ```
+     */
+    static create<Type, Props>(components?: [Type, FunctionComponent<Props>][]): TypedComponentRegistry<Type, Props>;
+}
+//# sourceMappingURL=componentRegistry.d.ts.map

package/dist/registry/componentRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentRegistry.d.ts","sourceRoot":"","sources":["../../src/registry/componentRegistry.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,WAAW,WAAW,CAAC,IAAI,GAAG,MAAM;IACxC;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAsB,CAAC,IAAI,EAAE,KAAK;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkD;IAE3E;;;;OAIG;IACH,IAAI,KAAK,IAAI,IAAI,EAAE,CAElB;IAED;;;;OAIG;IACH,IAAI,OAAO,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,EAAE,CAEhD;IAED;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAIxB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,IAAI;IAO/D;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAI5B;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,iBAAiB,CAAC,KAAK,CAAC,GAAG,SAAS;IAIrD;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EACvB,UAAU,GAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,EAAO,GAClD,sBAAsB,CAAC,IAAI,EAAE,KAAK,CAAC;CAOvC"}

package/dist/registry/index.d.ts

@@ -0,0 +1,2 @@
+export * from './componentRegistry';
+//# sourceMappingURL=index.d.ts.map

package/dist/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry/index.ts"],"names":[],"mappings":"AAaA,cAAc,qBAAqB,CAAC"}

package/dist/table/cell/AvatarCell.d.ts

@@ -0,0 +1,122 @@
+import { CellProps } from './types';
+import { AvatarProps } from 'antd/es/avatar';
+/**
+ * Constant representing the type identifier for avatar cells.
+ *
+ * This constant is used to register and identify avatar cell components
+ * in the cell registry system. It should be used when creating typed
+ * cell renderers for avatar-based table cells.
+ *
+ * @constant
+ * @type {string}
+ * @default 'avatar'
+ *
+ * @example
+ * ```tsx
+ * import { typedCellRender, AVATAR_CELL_TYPE } from './table/cell';
+ *
+ * const avatarRenderer = typedCellRender(AVATAR_CELL_TYPE, {
+ *   size: 32
+ * });
+ * ```
+ */
+export declare const AVATAR_CELL_TYPE = "avatar";
+/**
+ * Props for the AvatarCell component, extending CellProps with string value type and AvatarProps attributes.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @interface AvatarCellProps
+ * @extends CellProps<string, RecordType, AvatarProps>
+ *
+ * @example
+ * ```tsx
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   avatarUrl: string;
+ * }
+ *
+ * const props: AvatarCellProps<User> = {
+ *   data: {
+ *     value: "https://example.com/avatar.jpg",
+ *     record: { id: 1, name: "John", avatarUrl: "https://example.com/avatar.jpg" },
+ *     index: 0
+ *   },
+ *   attributes: {
+ *     size: 40,
+ *     alt: "User avatar"
+ *   }
+ * };
+ * ```
+ */
+export interface AvatarCellProps<RecordType = any> extends CellProps<string, RecordType, AvatarProps> {
+}
+/**
+ * Renders an avatar cell using Ant Design's Avatar component.
+ *
+ * This component displays user avatars in table cells with support for
+ * images, fallback text, and all Avatar component features. It handles
+ * null/undefined values gracefully by showing initials from the record name.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @param props - The props for the avatar cell component.
+ * @param props.data - The cell data containing value, record, and index.
+ * @param props.data.value - The avatar URL string or name to display.
+ * @param props.data.record - The full record object for context.
+ * @param props.data.index - The index of the row in the table.
+ * @param props.attributes - Optional attributes for the Avatar component.
+ * @returns A React element representing the avatar cell.
+ *
+ * @example
+ * ```tsx
+ * <AvatarCell
+ *   data={{
+ *     value: "https://example.com/avatar.jpg",
+ *     record: { id: 1, name: "John", avatar: "https://example.com/avatar.jpg" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     size: 32
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With fallback to initials
+ * <AvatarCell
+ *   data={{
+ *     value: "John Doe",
+ *     record: { id: 1, name: "John Doe" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     size: 40,
+ *     style: { backgroundColor: '#1890ff' }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With TypeScript
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   avatar?: string;
+ * }
+ *
+ * <AvatarCell<User>
+ *   data={{
+ *     value: user.avatar || user.name,
+ *     record: user,
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     size: 24
+ *   }}
+ * />
+ * ```
+ */
+export declare function AvatarCell<RecordType = any>(props: AvatarCellProps<RecordType>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AvatarCell.d.ts.map

package/dist/table/cell/AvatarCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarCell.d.ts","sourceRoot":"","sources":["../../../src/table/cell/AvatarCell.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,WAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,eAAe,CAAC,UAAU,GAAG,GAAG,CAC/C,SAAQ,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,CAAC;CAAG;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAgB,UAAU,CAAC,UAAU,GAAG,GAAG,EACzC,KAAK,EAAE,eAAe,CAAC,UAAU,CAAC,2CAenC"}

package/dist/table/cell/CalendarTime.d.ts

@@ -0,0 +1,178 @@
+import { Dayjs } from 'dayjs';
+import { CellProps } from './types';
+import { TextProps } from 'antd/es/typography/Text';
+/**
+ * Calendar format configuration for relative time display.
+ *
+ * Defines the format strings used by dayjs calendar plugin to display
+ * dates relative to the current time (e.g., "今天", "昨天", etc.).
+ *
+ * @interface CalendarFormats
+ *
+ * @example
+ * ```typescript
+ * const customFormats: CalendarFormats = {
+ *   sameDay: '[今天] HH:mm',
+ *   lastDay: '[昨天] HH:mm',
+ *   sameElse: 'YYYY-MM-DD HH:mm:ss'
+ * };
+ * ```
+ */
+export interface CalendarFormats {
+    /** Format for dates that are today */
+    sameDay?: string;
+    /** Format for dates that are tomorrow */
+    nextDay?: string;
+    /** Format for dates in the next week */
+    nextWeek?: string;
+    /** Format for dates that were yesterday */
+    lastDay?: string;
+    /** Format for dates in the last week */
+    lastWeek?: string;
+    /** Format for all other dates */
+    sameElse?: string;
+}
+/**
+ * Constant representing the type identifier for calendar time cells.
+ *
+ * This constant is used to register and identify calendar time cell components
+ * in the cell registry system. It should be used when creating typed
+ * cell renderers for calendar-based datetime table cells.
+ *
+ * @constant
+ * @type {string}
+ * @default 'calendar-time'
+ *
+ * @example
+ * ```tsx
+ * import { typedCellRender, CALENDAR_CELL_TYPE } from './table/cell';
+ *
+ * const calendarRenderer = typedCellRender(CALENDAR_CELL_TYPE, {
+ *   formats: {
+ *     sameDay: '[今天] HH:mm',
+ *     lastDay: '[昨天] HH:mm'
+ *   }
+ * });
+ * ```
+ */
+export declare const CALENDAR_CELL_TYPE = "calendar-time";
+/**
+ * Default calendar formats for Chinese locale.
+ *
+ * Provides sensible defaults for displaying relative dates in Chinese,
+ * falling back to standard datetime format for older dates.
+ *
+ * @constant
+ * @type {CalendarFormats}
+ */
+export declare const DEFAULT_CALENDAR_FORMATS: CalendarFormats;
+/**
+ * Props for the CalendarTimeCell component, extending CellProps with datetime value type and TextProps attributes.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @interface CalendarTimeProps
+ * @extends CellProps<string | number | Date | Dayjs, RecordType, TextProps & { formats?: CalendarFormats }>
+ *
+ * @example
+ * ```tsx
+ * interface Event {
+ *   id: number;
+ *   title: string;
+ *   createdAt: string;
+ *   updatedAt: number;
+ * }
+ *
+ * const props: CalendarTimeProps<Event> = {
+ *   data: {
+ *     value: "2024-01-15T10:30:45Z",
+ *     record: { id: 1, title: "Meeting", createdAt: "2024-01-15T10:30:45Z", updatedAt: 1705312200000 },
+ *     index: 0
+ *   },
+ *   attributes: {
+ *     formats: {
+ *       sameDay: "[今天] HH:mm",
+ *       lastDay: "[昨天] HH:mm"
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export interface CalendarTimeProps<RecordType = any> extends CellProps<string | number | Date | Dayjs, RecordType, TextProps & {
+    formats?: CalendarFormats;
+}> {
+}
+/**
+ * Renders a calendar time cell using Ant Design's Typography.Text component with dayjs calendar formatting.
+ *
+ * This component displays datetime values in table cells using relative time formats
+ * (e.g., "今天 10:30", "昨天 15:45") based on the current date. It supports various input formats
+ * (string, number timestamp, Date object, or Dayjs object) and customizable calendar formats
+ * through the dayjs calendar plugin. It provides consistent relative time display with fallback handling
+ * for invalid dates.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @param props - The props for the calendar time cell component.
+ * @param props.data - The cell data containing value, record, and index.
+ * @param props.data.value - The datetime value to display (string, number, Date, or Dayjs).
+ * @param props.data.record - The full record object for context.
+ * @param props.data.index - The index of the row in the table.
+ * @param props.attributes - Optional attributes including calendar formats and TextProps.
+ * @param props.attributes.formats - Optional calendar format configuration (default: DEFAULT_CALENDAR_FORMATS).
+ * @returns A React element representing the formatted calendar time cell.
+ *
+ * @example
+ * ```tsx
+ * <CalendarTimeCell
+ *   data={{
+ *     value: "2024-01-15T10:30:45Z",
+ *     record: { id: 1, title: "Event", createdAt: "2024-01-15T10:30:45Z" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     formats: {
+ *       sameDay: "[今天] HH:mm",
+ *       lastDay: "[昨天] HH:mm"
+ *     }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With TypeScript and timestamp
+ * interface Log {
+ *   id: number;
+ *   message: string;
+ *   timestamp: number;
+ * }
+ *
+ * <CalendarTimeCell<Log>
+ *   data={{
+ *     value: 1705312200000,
+ *     record: { id: 1, message: "User login", timestamp: 1705312200000 },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     formats: {
+ *       sameDay: "[今天] HH:mm",
+ *       lastDay: "[昨天] HH:mm"
+ *     },
+ *     style: { color: '#666' }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With Date object
+ * <CalendarTimeCell
+ *   data={{
+ *     value: new Date(),
+ *     record: { id: 1, title: "Current time" },
+ *     index: 0
+ *   }}
+ * />
+ * ```
+ */
+export declare function CalendarTimeCell<RecordType = any>(props: CalendarTimeProps<RecordType>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CalendarTime.d.ts.map

package/dist/table/cell/CalendarTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CalendarTime.d.ts","sourceRoot":"","sources":["../../../src/table/cell/CalendarTime.tsx"],"names":[],"mappings":"AAcA,OAAc,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAKpD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,eAOtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,iBAAiB,CAAC,UAAU,GAAG,GAAG,CACjD,SAAQ,SAAS,CACf,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,EAC9B,UAAU,EACV,SAAS,GAAG;IAAE,OAAO,CAAC,EAAE,eAAe,CAAA;CAAE,CAC1C;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,GAAG,GAAG,EAC/C,KAAK,EAAE,iBAAiB,CAAC,UAAU,CAAC,2CAQrC"}

package/dist/table/cell/CurrencyCell.d.ts

@@ -0,0 +1,275 @@
+import { CellProps } from './types';
+import { TextProps } from 'antd/es/typography/Text';
+import { CurrencyFormatOptions } from './currencyFormatter';
+/**
+ * Constant representing the type identifier for currency cells.
+ *
+ * This constant is used to register and identify currency cell components
+ * in the cell registry system. It should be used when creating typed
+ * cell renderers for currency-based table cells.
+ *
+ * @constant
+ * @type {string}
+ * @default 'currency'
+ *
+ * @example
+ * ```tsx
+ * import { typedCellRender, CURRENCY_CELL_TYPE } from './table/cell';
+ *
+ * const currencyRenderer = typedCellRender(CURRENCY_CELL_TYPE, {
+ *   format: {
+ *     currency: 'USD',
+ *     decimals: 2,
+ *     locale: 'en-US'
+ *   },
+ *   style: { fontWeight: 'bold' }
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using with cell registry
+ * import { cellRegistry, CURRENCY_CELL_TYPE } from './table/cell';
+ *
+ * const CurrencyCellComponent = cellRegistry.get(CURRENCY_CELL_TYPE);
+ * if (CurrencyCellComponent) {
+ *   // Use the component for rendering currency cells
+ * }
+ * ```
+ */
+export declare const CURRENCY_CELL_TYPE = "currency";
+/**
+ * Attributes for currency cell formatting, extending TextProps with currency-specific options.
+ *
+ * This interface combines Ant Design's TextProps for text styling with
+ * a format property containing CurrencyFormatOptions for currency formatting configuration.
+ * The format property is optional and allows customization of how currency values are displayed.
+ *
+ * @interface CurrencyAttributes
+ * @extends TextProps
+ *
+ * @property {CurrencyFormatOptions} [format] - Optional currency formatting options.
+ *   When not provided, uses default currency formatting (CNY, zh-CN locale, 2 decimals).
+ * @property {boolean} [ellipsis] - Whether to truncate text with ellipsis when it overflows.
+ * @property {React.CSSProperties} [style] - Custom CSS styles to apply to the text element.
+ * @property {string} [className] - Additional CSS class names to apply to the text element.
+ * @property {React.ReactNode} [children] - Custom content to display instead of the formatted currency value.
+ *
+ * @example
+ * ```tsx
+ * const attributes: CurrencyAttributes = {
+ *   format: {
+ *     currency: 'USD',
+ *     currencyDisplay: 'symbol',
+ *     decimals: 2,
+ *     locale: 'en-US',
+ *     useGrouping: true
+ *   },
+ *   ellipsis: true,
+ *   style: { color: 'green', fontWeight: 'bold' },
+ *   className: 'currency-text'
+ * };
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using only text styling without currency formatting
+ * const attributes: CurrencyAttributes = {
+ *   style: { color: 'red' },
+ *   ellipsis: true
+ * };
+ * ```
+ */
+export interface CurrencyAttributes extends TextProps {
+    format?: CurrencyFormatOptions;
+}
+/**
+ * Props for the CurrencyCell component, extending CellProps with numeric value type and CurrencyAttributes.
+ *
+ * This interface defines the complete props structure for the CurrencyCell component,
+ * combining cell data with optional formatting and styling attributes.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @interface CurrencyCellProps
+ * @extends CellProps<number | string, RecordType, CurrencyAttributes>
+ *
+ * @property {CellData<number | string, RecordType>} data - The cell data containing the value to format.
+ * @property {CurrencyAttributes} [attributes] - Optional attributes for currency formatting and text styling.
+ *
+ * @example
+ * ```tsx
+ * interface Product {
+ *   id: number;
+ *   name: string;
+ *   price: number;
+ * }
+ *
+ * const props: CurrencyCellProps<Product> = {
+ *   data: {
+ *     value: 1234.56,
+ *     record: { id: 1, name: "Widget", price: 1234.56 },
+ *     index: 0
+ *   },
+ *   attributes: {
+ *     format: {
+ *       currency: 'USD',
+ *       decimals: 2,
+ *       locale: 'en-US'
+ *     },
+ *     ellipsis: true,
+ *     style: { fontWeight: 'bold' }
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With string values (automatically parsed)
+ * const props: CurrencyCellProps = {
+ *   data: {
+ *     value: "999.99",
+ *     record: { id: 1, amount: "999.99" },
+ *     index: 0
+ *   },
+ *   attributes: {
+ *     format: {
+ *       currency: 'EUR',
+ *       currencyDisplay: 'code'
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export interface CurrencyCellProps<RecordType = any> extends CellProps<number | string, RecordType, CurrencyAttributes> {
+}
+/**
+ * Renders a currency cell using the formatCurrency function and Ant Design's Typography.Text component.
+ *
+ * This component displays numeric values formatted as localized currency strings in table cells.
+ * It supports various currencies, locales, decimal precision, and formatting options while
+ * providing text styling capabilities through Ant Design's Typography.Text component.
+ *
+ * The component automatically handles invalid values (null, undefined, NaN, Infinity) by
+ * displaying a fallback string, and supports both numeric and string inputs that are
+ * automatically parsed.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @param {CurrencyCellProps<RecordType>} props - The props for the currency cell component.
+ * @param {CellData<number | string, RecordType>} props.data - The cell data containing value, record, and index.
+ * @param {number | string} props.data.value - The numeric or string value to format as currency.
+ *   String values are automatically parsed, removing non-numeric characters except decimal points and minus signs.
+ * @param {RecordType} props.data.record - The full record object providing context for the cell.
+ * @param {number} props.data.index - The zero-based index of the row in the table.
+ * @param {CurrencyAttributes} [props.attributes] - Optional attributes for currency formatting and text styling.
+ * @param {CurrencyFormatOptions} [props.attributes.format] - Currency formatting options including currency code, locale, decimals, etc.
+ * @param {boolean} [props.attributes.ellipsis] - Whether to truncate text with ellipsis when it overflows.
+ * @param {React.CSSProperties} [props.attributes.style] - Custom CSS styles to apply to the text element.
+ * @param {string} [props.attributes.className] - Additional CSS class names to apply to the text element.
+ * @param {React.ReactNode} [props.attributes.children] - Custom content to display instead of the formatted currency value.
+ * @returns {React.ReactElement} A React element representing the formatted currency cell using Typography.Text.
+ *
+ * @throws {Error} This component does not throw errors directly, but may propagate errors from the formatCurrency function
+ *   if invalid currency codes or locales are provided in the format options.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with USD formatting
+ * <CurrencyCell
+ *   data={{
+ *     value: 1234.56,
+ *     record: { id: 1, name: "Product", price: 1234.56 },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     format: {
+ *       currency: 'USD',
+ *       decimals: 2,
+ *       locale: 'en-US'
+ *     },
+ *     ellipsis: true,
+ *     style: { fontWeight: 'bold' }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With TypeScript and EUR currency
+ * interface Transaction {
+ *   id: string;
+ *   amount: number;
+ *   currency: string;
+ * }
+ *
+ * <CurrencyCell<Transaction>
+ *   data={{
+ *     value: 999.99,
+ *     record: { id: "tx-123", amount: 999.99, currency: "EUR" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     format: {
+ *       currency: 'EUR',
+ *       currencyDisplay: 'code',
+ *       decimals: 2,
+ *       locale: 'de-DE'
+ *     },
+ *     style: { color: 'green' }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using string values (automatically parsed)
+ * <CurrencyCell
+ *   data={{
+ *     value: "1,234.56",
+ *     record: { id: 1, amount: "1,234.56" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     format: {
+ *       currency: 'CNY',
+ *       useGrouping: true
+ *     }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handling invalid values (displays fallback)
+ * <CurrencyCell
+ *   data={{
+ *     value: NaN,
+ *     record: { id: 1, amount: NaN },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     format: {
+ *       currency: 'USD',
+ *       fallback: 'N/A'
+ *     }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Custom content override
+ * <CurrencyCell
+ *   data={{
+ *     value: 100,
+ *     record: { id: 1, amount: 100 },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     format: { currency: 'USD' },
+ *     children: <span style={{ color: 'red' }}>Custom Content</span>
+ *   }}
+ * />
+ * ```
+ */
+export declare function CurrencyCell<RecordType = any>(props: CurrencyCellProps<RecordType>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CurrencyCell.d.ts.map

package/dist/table/cell/CurrencyCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CurrencyCell.d.ts","sourceRoot":"","sources":["../../../src/table/cell/CurrencyCell.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAkB,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAI5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,WAAW,kBAAmB,SAAQ,SAAS;IACnD,MAAM,CAAC,EAAE,qBAAqB,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,WAAW,iBAAiB,CAAC,UAAU,GAAG,GAAG,CACjD,SAAQ,SAAS,CAAC,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,kBAAkB,CAAC;CAAG;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgIG;AACH,wBAAgB,YAAY,CAAC,UAAU,GAAG,GAAG,EAC3C,KAAK,EAAE,iBAAiB,CAAC,UAAU,CAAC,2CAMrC"}