@ahoo-wang/fetcher-viewer 3.1.8 → 3.2.0

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

@@ -0,0 +1,128 @@
+import { CellProps } from './types';
+import { TagProps } from 'antd';
+import { SpaceProps } from 'antd/es/space';
+/**
+ * Constant representing the type identifier for tags cells.
+ *
+ * This constant is used to register and identify tags cell components
+ * in the cell registry system. It should be used when creating typed
+ * cell renderers for tags-based table cells.
+ *
+ * @constant
+ * @type {string}
+ * @default 'tags'
+ *
+ * @example
+ * ```tsx
+ * import { typedCellRender, TAGS_CELL_TYPE } from './table/cell';
+ *
+ * const tagsRenderer = typedCellRender(TAGS_CELL_TYPE, {
+ *   'urgent': { color: 'red' },
+ *   'normal': { color: 'blue' }
+ * });
+ * ```
+ */
+export declare const TAGS_CELL_TYPE = "tags";
+/**
+ * Props for the TagsCell component, extending CellProps with string array value type and tag attributes mapping.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @interface TagsCellProps
+ * @extends CellProps<string[], RecordType, Record<string, TagProps>>
+ *
+ * @example
+ * ```tsx
+ * interface Product {
+ *   id: number;
+ *   name: string;
+ *   tags: string[];
+ *   category: string;
+ * }
+ *
+ * const props: TagsCellProps<Product> = {
+ *   data: {
+ *     value: ["electronics", "bestseller"],
+ *     record: { id: 1, name: "Laptop", tags: ["electronics", "bestseller"], category: "computers" },
+ *     index: 0
+ *   },
+ *   attributes: {
+ *     "electronics": { color: "blue" },
+ *     "bestseller": { color: "gold" }
+ *   }
+ * };
+ * ```
+ */
+export interface TagsCellProps<RecordType = any> extends CellProps<string[], RecordType, Record<string, TagProps>> {
+    space?: SpaceProps;
+}
+/**
+ * Renders a tags cell using Ant Design's Space and Tag components.
+ *
+ * This component displays multiple string tags in table cells, with each tag
+ * rendered using the TagCell component. It supports individual tag styling
+ * through attributes mapping and automatically filters out empty or whitespace-only tags.
+ * Tags are displayed horizontally in a Space component for proper spacing.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @param props - The props for the tags cell component.
+ * @param props.data - The cell data containing value array, record, and index.
+ * @param props.data.value - The array of string tags to display in the cell.
+ * @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 mapping of tag names to TagProps for individual tag styling.
+ * @returns A React element containing the tags wrapped in a Space component, or null if no valid tags.
+ *
+ * @example
+ * ```tsx
+ * <TagsCell
+ *   data={{
+ *     value: ["urgent", "frontend", "bug"],
+ *     record: { id: 1, title: "Fix login issue", tags: ["urgent", "frontend", "bug"] },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     "urgent": { color: "red" },
+ *     "frontend": { color: "blue" },
+ *     "bug": { color: "orange" }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With TypeScript
+ * interface Task {
+ *   id: number;
+ *   title: string;
+ *   tags: string[];
+ *   priority: string;
+ * }
+ *
+ * <TagsCell<Task>
+ *   data={{
+ *     value: ["urgent", "frontend"],
+ *     record: { id: 1, title: "Task", tags: ["urgent", "frontend"], priority: "high" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     "urgent": { color: "red", closable: true },
+ *     "frontend": { color: "geekblue" }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Empty tags array - renders nothing
+ * <TagsCell
+ *   data={{
+ *     value: [],
+ *     record: { id: 1, title: "Task" },
+ *     index: 0
+ *   }}
+ *   attributes={{}}
+ * />
+ * ```
+ */
+export declare function TagsCell<RecordType = any>(props: TagsCellProps<RecordType>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=TagsCell.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TagsCell.d.ts","sourceRoot":"","sources":["../../../src/table/cell/TagsCell.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAS,QAAQ,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,SAAS,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,aAAa,CAAC,UAAU,GAAG,GAAG,CAC7C,SAAQ,SAAS,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjE,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,QAAQ,CAAC,UAAU,GAAG,GAAG,EAAE,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,kDAmB1E"}

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

@@ -0,0 +1,101 @@
+import { CellProps } from './types';
+import { TextProps } from 'antd/es/typography/Text';
+/**
+ * Constant representing the type identifier for text cells.
+ *
+ * This constant is used to register and identify text cell components
+ * in the cell registry system. It should be used when creating typed
+ * cell renderers for text-based table cells.
+ *
+ * @constant
+ * @type {string}
+ * @default 'text'
+ *
+ * @example
+ * ```tsx
+ * import { typedCellRender, TEXT_CELL_TYPE } from './table/cell';
+ *
+ * const textRenderer = typedCellRender(TEXT_CELL_TYPE, { ellipsis: true });
+ * ```
+ */
+export declare const TEXT_CELL_TYPE = "text";
+/**
+ * Props for the TextCell component, extending CellProps with string value type and TextProps attributes.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @interface TextCellProps
+ * @extends CellProps<string, RecordType, TextProps>
+ *
+ * @example
+ * ```tsx
+ * interface User {
+ *   id: number;
+ *   name: string;
+ * }
+ *
+ * const props: TextCellProps<User> = {
+ *   data: {
+ *     value: "John Doe",
+ *     record: { id: 1, name: "John Doe" },
+ *     index: 0
+ *   },
+ *   attributes: { ellipsis: true }
+ * };
+ * ```
+ */
+export interface TextCellProps<RecordType = any> extends CellProps<string, RecordType, TextProps> {
+}
+/**
+ * Renders a text cell using Ant Design's Typography.Text component.
+ *
+ * This component displays string values in table cells with support for
+ * various text formatting options provided by Ant Design's Typography.Text.
+ * It handles the rendering of text content while allowing customization
+ * through attributes like ellipsis, styling, and other TextProps.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @param props - The props for the text cell component.
+ * @param props.data - The cell data containing value, record, and index.
+ * @param props.data.value - The string value to display in the cell.
+ * @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 to pass to Typography.Text component.
+ * @returns A React element representing the text cell.
+ *
+ * @throws {Error} If the value cannot be rendered as React children (e.g., objects).
+ *
+ * @example
+ * ```tsx
+ * <TextCell
+ *   data={{
+ *     value: "Hello World",
+ *     record: { id: 1, name: "John" },
+ *     index: 0
+ *   }}
+ *   attributes={{
+ *     ellipsis: true,
+ *     style: { color: 'blue' }
+ *   }}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With TypeScript
+ * interface User {
+ *   id: number;
+ *   name: string;
+ * }
+ *
+ * <TextCell<User>
+ *   data={{
+ *     value: "John Doe",
+ *     record: { id: 1, name: "John Doe" },
+ *     index: 0
+ *   }}
+ *   attributes={{ ellipsis: { tooltip: true } }}
+ * />
+ * ```
+ */
+export declare function TextCell<RecordType = any>(props: TextCellProps<RecordType>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=TextCell.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextCell.d.ts","sourceRoot":"","sources":["../../../src/table/cell/TextCell.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIpD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,SAAS,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,aAAa,CAAC,UAAU,GAAG,GAAG,CAC7C,SAAQ,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,QAAQ,CAAC,UAAU,GAAG,GAAG,EAAE,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,2CAE1E"}

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

@@ -0,0 +1,99 @@
+import type * as React from 'react';
+/**
+ * Represents the type identifier for different cell components.
+ *
+ * Cell types are string identifiers used to register and retrieve
+ * specific cell rendering components from the cell registry.
+ * Common types include 'text', 'number', 'date', etc.
+ *
+ * @typedef {string} CellType
+ *
+ * @example
+ * ```tsx
+ * const textType: CellType = 'text';
+ * const customType: CellType = 'custom-cell';
+ * ```
+ */
+export type CellType = string;
+/**
+ * A function type for rendering typed cells, supporting both synchronous and asynchronous rendering.
+ *
+ * Cell renderers are functions that take cell data and return React nodes
+ * for display in table cells. They can be synchronous for immediate rendering
+ * or asynchronous for cases requiring data fetching or complex computations.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @typedef CellRenderer
+ * @param value - The value to render in the cell. Can be any type depending on the cell implementation.
+ * @param record - The full record object providing context for the cell rendering.
+ * @param index - The zero-based index of the row in the table.
+ * @returns A React node for synchronous rendering, or a Promise resolving to a React node for asynchronous rendering.
+ *
+ * @example
+ * ```tsx
+ * // Synchronous renderer
+ * const textRenderer: CellRenderer<User> = (value, record, index) => {
+ *   return <span>{String(value)}</span>;
+ * };
+ *
+ * // Asynchronous renderer
+ * const asyncRenderer: CellRenderer<User> = async (value, record, index) => {
+ *   const formatted = await formatValue(value);
+ *   return <span>{formatted}</span>;
+ * };
+ * ```
+ */
+export type CellRenderer<RecordType = any> = (value: any, record: RecordType, index: number) => React.ReactNode;
+/**
+ * Creates a typed cell renderer function for a given cell type.
+ *
+ * This function retrieves a cell component from the registry based on the
+ * provided type and returns a renderer function that can be used to render
+ * cells of that type. The returned renderer encapsulates the component and
+ * its attributes for repeated use.
+ *
+ * @template RecordType - The type of the record containing the cell data.
+ * @template Attributes - The type of additional attributes for the cell component.
+ * @param type - The cell type identifier to look up in the registry (e.g., 'text', 'number').
+ * @param attributes - Optional attributes object to pass to the cell component for customization.
+ * @returns A renderer function for the specified cell type, or undefined if the type is not registered.
+ *
+ * @throws {Error} This function itself doesn't throw, but the returned renderer may throw
+ *                 if the underlying component encounters rendering errors.
+ *
+ * @example
+ * ```tsx
+ * // Create a text renderer with ellipsis
+ * const textRenderer = typedCellRender('text', { ellipsis: true });
+ *
+ * // Use the renderer to create cells
+ * const cell1 = textRenderer('Hello World', { id: 1 }, 0);
+ * const cell2 = textRenderer('Long text...', { id: 2 }, 1);
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With TypeScript types
+ * interface User {
+ *   id: number;
+ *   name: string;
+ * }
+ *
+ * const userNameRenderer = typedCellRender<User>('text', {
+ *   style: { fontWeight: 'bold' }
+ * });
+ *
+ * const cell = userNameRenderer('John Doe', { id: 1, name: 'John Doe' }, 0);
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handling unregistered types
+ * const unknownRenderer = typedCellRender('unknown-type');
+ * if (!unknownRenderer) {
+ *   console.warn('Unknown cell type');
+ * }
+ * ```
+ */
+export declare function typedCellRender<RecordType = any, Attributes = any>(type: CellType, attributes?: Attributes): CellRenderer<RecordType> | undefined;
+//# sourceMappingURL=TypedCell.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TypedCell.d.ts","sourceRoot":"","sources":["../../../src/table/cell/TypedCell.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,YAAY,CAAC,UAAU,GAAG,GAAG,IAAI,CAC3C,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,KACV,KAAK,CAAC,SAAS,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,eAAe,CAAC,UAAU,GAAG,GAAG,EAAE,UAAU,GAAG,GAAG,EAChE,IAAI,EAAE,QAAQ,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,YAAY,CAAC,UAAU,CAAC,GAAG,SAAS,CAgBtC"}

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

@@ -0,0 +1,40 @@
+import { TypedComponentRegistry } from '../../registry';
+import { CellProps } from './types';
+/**
+ * Registry for cell components, mapping cell types to their corresponding components.
+ *
+ * This registry instance manages the available cell component types for table rendering.
+ * It is pre-initialized with the text cell component and can be extended with additional
+ * cell types as needed. The registry provides type-safe component resolution for
+ * dynamic cell rendering based on data types.
+ *
+ * @constant
+ * @type {TypedComponentRegistry<CellType, CellProps>}
+ *
+ * @example
+ * ```tsx
+ * // Get a registered component
+ * const TextCellComponent = cellRegistry.get('text');
+ *
+ * // Check if a type is registered
+ * if (cellRegistry.has('number')) {
+ *   // Use number cell
+ * }
+ *
+ * // Register a custom cell type
+ * cellRegistry.register('custom', CustomCellComponent);
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Using with typedCellRender
+ * import { typedCellRender } from './TypedCell';
+ *
+ * const renderer = typedCellRender('text', { ellipsis: true });
+ * if (renderer) {
+ *   const cell = renderer('Hello', { id: 1 }, 0);
+ * }
+ * ```
+ */
+export declare const cellRegistry: TypedComponentRegistry<string, CellProps<any, any, any>>;
+//# sourceMappingURL=cellRegistry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cellRegistry.d.ts","sourceRoot":"","sources":["../../../src/table/cell/cellRegistry.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAYpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,0DAWvB,CAAC"}

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

@@ -0,0 +1,161 @@
+/**
+ * Configuration options for currency formatting.
+ *
+ * This interface extends a subset of Intl.NumberFormatOptions with additional
+ * currency-specific formatting controls. It provides a comprehensive set of
+ * options for customizing how monetary values are displayed.
+ *
+ * @example
+ * ```typescript
+ * const options: CurrencyFormatOptions = {
+ *   currency: 'USD',
+ *   currencyDisplay: 'symbol',
+ *   decimals: 2,
+ *   locale: 'en-US',
+ *   useGrouping: true,
+ *   fallback: 'N/A'
+ * };
+ * ```
+ */
+export interface CurrencyFormatOptions {
+    /**
+     * The currency code to use for formatting (ISO 4217 currency codes).
+     * Common values include 'USD', 'EUR', 'CNY', 'JPY', etc.
+     *
+     * @type {string}
+     * @default 'CNY'
+     * @example 'USD', 'EUR', 'CNY', 'JPY'
+     */
+    currency?: string;
+    /**
+     * How to display the currency in the formatted output.
+     * - 'symbol': Use currency symbol (e.g., $, €, ¥)
+     * - 'narrowSymbol': Use narrow currency symbol when available
+     * - 'code': Use currency code (e.g., USD, EUR, CNY)
+     * - 'name': Use currency name (e.g., US dollar, euro, Chinese yuan)
+     *
+     * @type {Intl.NumberFormatOptionsCurrencyDisplay}
+     * @default 'symbol'
+     */
+    currencyDisplay?: Intl.NumberFormatOptionsCurrencyDisplay;
+    /**
+     * The number of decimal places to display.
+     * This controls both minimum and maximum fraction digits.
+     *
+     * @type {number}
+     * @default 2
+     * @example 2, 3, 0
+     */
+    decimals?: number;
+    /**
+     * The locale to use for formatting (BCP 47 language tag).
+     * This affects number formatting, currency symbols, and grouping separators.
+     *
+     * @type {string}
+     * @default 'zh-CN'
+     * @example 'en-US', 'zh-CN', 'ja-JP', 'de-DE'
+     */
+    locale?: string;
+    /**
+     * Whether to use grouping separators (thousands separators).
+     * When true, large numbers will be formatted with separators (e.g., 1,234.56).
+     *
+     * @type {boolean}
+     * @default true
+     */
+    useGrouping?: boolean;
+    /**
+     * The fallback string to return when the input value is invalid, null, undefined, or NaN.
+     * This ensures consistent output for edge cases.
+     *
+     * @type {string}
+     * @default '-'
+     * @example '-', 'N/A', 'Invalid', ''
+     */
+    fallback?: string;
+}
+/**
+ * Default configuration options for currency formatting.
+ *
+ * These defaults are used when no options are provided to formatCurrency().
+ * They provide sensible defaults for Chinese Yuan (CNY) formatting with
+ * standard decimal places and grouping separators.
+ *
+ * @constant
+ * @type {CurrencyFormatOptions}
+ *
+ * @example
+ * ```typescript
+ * // Using defaults
+ * formatCurrency(1234.56); // Uses DEFAULT_CURRENCY_FORMAT_OPTIONS
+ *
+ * // Overriding specific options
+ * formatCurrency(1234.56, { currency: 'USD' }); // Merges with defaults
+ * ```
+ */
+export declare const DEFAULT_CURRENCY_FORMAT_OPTIONS: CurrencyFormatOptions;
+/**
+ * Formats a numeric amount as a localized currency string.
+ *
+ * This function provides comprehensive currency formatting using the browser's
+ * Intl.NumberFormat API. It supports various currencies, locales, and formatting
+ * options while providing robust error handling and fallback behavior.
+ *
+ * @param {number | string} amount - The monetary amount to format. Can be a number or a string representation of a number.
+ * @param {CurrencyFormatOptions} [options=DEFAULT_CURRENCY_FORMAT_OPTIONS] - Formatting options to customize the output.
+ * @returns {string} The formatted currency string, or the fallback value if formatting fails.
+ *
+ * @throws {Error} May throw if the Intl.NumberFormat constructor fails with invalid options, but this is handled internally with fallback.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults (CNY, zh-CN locale)
+ * formatCurrency(1234.56); // "¥1,234.56"
+ * formatCurrency(0); // "¥0.00"
+ * formatCurrency(null); // "-"
+ *
+ * // Using USD with US locale
+ * formatCurrency(1234.56, {
+ *   currency: 'USD',
+ *   locale: 'en-US'
+ * }); // "$1,234.56"
+ *
+ * // Formatting with custom decimal places
+ * formatCurrency(1234.56789, {
+ *   currency: 'EUR',
+ *   decimals: 3,
+ *   locale: 'de-DE'
+ * }); // "1.234,568 €"
+ *
+ * // Large numbers with grouping
+ * formatCurrency(1234567.89, {
+ *   currency: 'CNY',
+ *   useGrouping: true
+ * }); // "¥1,234,567.89"
+ *
+ * // Without grouping separators
+ * formatCurrency(1234567.89, {
+ *   currency: 'CNY',
+ *   useGrouping: false
+ * }); // "¥1234567.89"
+ *
+ * // Custom fallback for invalid values
+ * formatCurrency(NaN, {
+ *   fallback: 'Invalid amount'
+ * }); // "Invalid amount"
+ *
+ * // String input (automatically parsed)
+ * formatCurrency('1234.56'); // "¥1,234.56"
+ * formatCurrency('$1,234.56'); // "¥1234.56" (non-numeric characters removed)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Error handling - function gracefully handles edge cases
+ * formatCurrency(Infinity); // "-"
+ * formatCurrency(-Infinity); // "-"
+ * formatCurrency('not-a-number'); // "-"
+ * ```
+ */
+export declare function formatCurrency(amount: number | string | null, options?: CurrencyFormatOptions): string;
+//# sourceMappingURL=currencyFormatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"currencyFormatter.d.ts","sourceRoot":"","sources":["../../../src/table/cell/currencyFormatter.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,IAAI,CAAC,kCAAkC,CAAC;IAE1D;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,+BAA+B,EAAE,qBAO7C,CAAC;AAaF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAC9B,OAAO,GAAE,qBAAuD,GAC/D,MAAM,CAwBR"}

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

@@ -0,0 +1,54 @@
+/**
+ * @module table/cell
+ *
+ * This module provides the core cell rendering system for tables, including:
+ * - Cell component types and interfaces
+ * - Text, tag and tags cell implementations
+ * - Typed cell rendering utilities
+ * - Cell registry for component management
+ *
+ * @example
+ * ```tsx
+ * import { TextCell, TagCell, TagsCell, typedCellRender, TEXT_CELL_TYPE, TAG_CELL_TYPE, TAGS_CELL_TYPE } from '@ahoo-wang/fetcher-viewer/table/cell';
+ *
+ * // Direct component usage
+ * <TextCell
+ *   data={{ value: 'Hello', record: { id: 1 }, index: 0 }}
+ *   attributes={{ ellipsis: true }}
+ * />
+ *
+ * <TagCell
+ *   data={{ value: "urgent", record: { id: 1 }, index: 0 }}
+ *   attributes={{ color: 'red' }}
+ * />
+ *
+ * <TagsCell
+ *   data={{ value: ["urgent", "high"], record: { id: 1 }, index: 0 }}
+ *   attributes={{ color: 'blue' }}
+ * />
+ *
+ * // Using typed renderer
+ * const textRenderer = typedCellRender(TEXT_CELL_TYPE, { ellipsis: true });
+ * const tagRenderer = typedCellRender(TAG_CELL_TYPE, { color: 'red' });
+ * const tagsRenderer = typedCellRender(TAGS_CELL_TYPE, { color: 'blue' });
+ * const textCell = textRenderer('Hello', { id: 1 }, 0);
+ * const tagCell = tagRenderer('urgent', { id: 1 }, 0);
+ * const tagsCell = tagsRenderer(['urgent', 'high'], { id: 1 }, 0);
+ * ```
+ */
+export * from './AvatarCell';
+export * from './CalendarTime';
+export * from './cellRegistry';
+export * from './currencyFormatter';
+export * from './CurrencyCell';
+export * from './DateTimeCell';
+export * from './ImageCell';
+export * from './ImageGroupCell';
+export * from './LinkCell';
+export * from './TagCell';
+export * from './TagsCell';
+export * from './TextCell';
+export * from './TypedCell';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/table/cell/index.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}