@1money/component-ui 0.0.1

package/es/components/Switch/style/Switch.scss

@@ -0,0 +1,126 @@
+@use '@/styles/api' as theme;
+
+$component: 'switch';
+$track-width: 40px;
+$track-height: 24px;
+$thumb-size: 20px;
+$thumb-offset: 2px;
+$thumb-travel: $track-width - $thumb-size - $thumb-offset * 2;
+
+.#{theme.$prefix}-#{$component} {
+  display: inline-flex;
+  gap: theme.spacing(gap, 300);
+  align-items: center;
+  cursor: pointer;
+
+  // ── Track wrapper (contains hidden input + visual track) ──
+  &-track-wrapper {
+    position: relative;
+    display: flex;
+    flex-shrink: 0;
+    align-items: center;
+  }
+
+  // ── Hidden native input ──
+  &-input {
+    position: absolute;
+    inset: 0;
+    margin: 0;
+    cursor: inherit;
+    opacity: 0;
+  }
+
+  // ── Visual track ──
+  &-track {
+    position: relative;
+    display: flex;
+    align-items: center;
+    width: $track-width;
+    height: $track-height;
+    background-color: theme.palette(bg, 'neutral-secondary');
+    border-radius: theme.shape('full');
+    transition:
+      background-color 0.2s ease,
+      border-color 0.2s ease;
+  }
+
+  // ── Thumb ──
+  &-thumb {
+    position: absolute;
+    left: $thumb-offset;
+    width: $thumb-size;
+    height: $thumb-size;
+    background-color: theme.palette(bg, 'default');
+    border-radius: theme.shape('full');
+    box-shadow: theme.shadows(100);
+    transform: translateX(0);
+    transition: transform 0.2s ease;
+  }
+
+  // ── Focus ring ──
+  &-input:focus-visible + .#{theme.$prefix}-#{$component}-track {
+    box-shadow: 0 0 0 2px theme.palette(border, 'brand');
+  }
+
+  // ── Label content ──
+  &-content {
+    display: flex;
+    flex: 1 0 0;
+    flex-direction: column;
+    min-width: 0;
+  }
+
+  // ── Description ──
+  &-description {
+    min-height: 20px;
+  }
+
+  // ── Hover ──
+  &:not(&-disabled):hover {
+    .#{theme.$prefix}-#{$component}-track {
+      background-color: theme.palette(bg, 'neutral-secondary-hover');
+    }
+  }
+
+  // ── Checked state ──
+  &-checked {
+    .#{theme.$prefix}-#{$component}-track {
+      background-color: theme.palette(bg, 'brand');
+    }
+
+    .#{theme.$prefix}-#{$component}-thumb {
+      transform: translateX($thumb-travel);
+    }
+  }
+
+  &-checked:not(&-disabled):hover {
+    .#{theme.$prefix}-#{$component}-track {
+      background-color: theme.palette(bg, 'brand-hover');
+    }
+  }
+
+  // ── Disabled state ──
+  &-disabled {
+    cursor: not-allowed;
+
+    .#{theme.$prefix}-#{$component}-track {
+      background-color: theme.palette(bg, 'disabled');
+    }
+
+    .#{theme.$prefix}-#{$component}-thumb {
+      background-color: theme.palette(bg, 'default');
+      box-shadow: none;
+    }
+
+    .#{theme.$prefix}-#{$component}-content {
+      color: theme.palette(text, 'disabled');
+    }
+  }
+
+  // ── Right label placement (label after switch) ──
+  &-right {
+    .#{theme.$prefix}-#{$component}-track-wrapper {
+      order: -1;
+    }
+  }
+}

package/es/components/Switch/style/css.js

@@ -0,0 +1,3 @@
+import '@/components/Typography/style/css';
+import './Switch.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvU3dpdGNoL3NyYy9jb21wb25lbnRzL1N3aXRjaC9zdHlsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLCtCQUErQjtBQUN0QyxPQUFPLGVBQWUiLCJmaWxlIjoiY29tcG9uZW50cy9Td2l0Y2gvc3R5bGUvY3NzLmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/components/Switch/style/index.d.ts

@@ -0,0 +1,2 @@
+import "../../Typography/style";
+import './Switch.scss';

package/es/components/Switch/style/index.js

@@ -0,0 +1,3 @@
+import '@/components/Typography/style';
+import './Switch.scss';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvU3dpdGNoL3NyYy9jb21wb25lbnRzL1N3aXRjaC9zdHlsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLCtCQUErQjtBQUN0QyxPQUFPLGVBQWUiLCJmaWxlIjoiY29tcG9uZW50cy9Td2l0Y2gvc3R5bGUvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Table/Table.d.ts

@@ -0,0 +1,10 @@
+import { type ReactElement, type Ref } from 'react';
+import './style';
+import type { TableProps, TableRef } from './interface';
+type ForwardGenericTable = (<T extends Record<string, any> = Record<string, any>>(props: TableProps<T> & {
+    ref?: Ref<TableRef>;
+}) => ReactElement | null) & {
+    displayName?: string;
+};
+export declare const Table: ForwardGenericTable;
+export default Table;

package/es/components/Table/Table.js

@@ -0,0 +1,164 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, memo, useMemo } from 'react';
+import classnames, { joinCls } from '../../utils/classnames';
+import { useMemoizedFn } from '@1money/hooks';
+import { Pagination } from '../Pagination';
+import { Spinner } from '../Spinner';
+import './style';
+import { InternalRcTable } from './internal';
+import { TABLE_BLOCK, TABLE_DEFAULT_PREFIX, TABLE_DEFAULT_SIZE, TABLE_DEFAULT_VARIANT } from './constants';
+import { useTableDataPipeline } from './core/useTableDataPipeline';
+import { useTableSelection } from './core/useTableSelection';
+import { useTableExpand } from './core/useTableExpand';
+import { useTableColumns } from './core/useTableColumns';
+import { ExpandedRowContainer } from './renderers/ExpandedRowContainer';
+import { TableEmptyState } from './renderers/EmptyState';
+var TableInner = function TableInner(props, ref) {
+  var _props$className = props.className,
+    className = _props$className === void 0 ? '' : _props$className,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? TABLE_DEFAULT_PREFIX : _props$prefixCls,
+    _props$size = props.size,
+    size = _props$size === void 0 ? TABLE_DEFAULT_SIZE : _props$size,
+    _props$variant = props.variant,
+    variant = _props$variant === void 0 ? TABLE_DEFAULT_VARIANT : _props$variant,
+    columns = props.columns,
+    dataSource = props.dataSource,
+    rowKey = props.rowKey,
+    empty = props.empty,
+    bordered = props.bordered,
+    pagination = props.pagination,
+    rowSelection = props.rowSelection,
+    loading = props.loading,
+    onChange = props.onChange,
+    childrenColumnName = props.childrenColumnName,
+    indentSize = props.indentSize,
+    expandable = props.expandable,
+    onRow = props.onRow,
+    rowClassName = props.rowClassName,
+    summary = props.summary,
+    showHeader = props.showHeader,
+    tableLayout = props.tableLayout,
+    components = props.components,
+    direction = props.direction,
+    rowHoverable = props.rowHoverable,
+    rest = __rest(props, ["className", "prefixCls", "size", "variant", "columns", "dataSource", "rowKey", "empty", "bordered", "pagination", "rowSelection", "loading", "onChange", "childrenColumnName", "indentSize", "expandable", "onRow", "rowClassName", "summary", "showHeader", "tableLayout", "components", "direction", "rowHoverable"]);
+  var cls = classnames(TABLE_BLOCK);
+  var getRowKey = useMemoizedFn(function (record, index) {
+    var _a;
+    return typeof rowKey === 'function' ? rowKey(record) : (_a = record[rowKey !== null && rowKey !== void 0 ? rowKey : 'key']) !== null && _a !== void 0 ? _a : index;
+  });
+  var pipeline = useTableDataPipeline({
+    columns: columns,
+    dataSource: dataSource,
+    pagination: pagination,
+    onChange: onChange
+  });
+  var selection = useTableSelection({
+    rowSelection: rowSelection,
+    dataSource: dataSource,
+    currentDataSource: pipeline.currentDataSource,
+    getRowKey: getRowKey
+  });
+  var expand = useTableExpand({
+    expandable: expandable
+  });
+  var renderedColumns = useTableColumns({
+    columns: columns,
+    size: size,
+    variant: variant,
+    expandable: expandable,
+    mergedExpandedRowKeys: expand.mergedExpandedRowKeys,
+    triggerExpand: expand.triggerExpand,
+    rowSelection: rowSelection,
+    mergedSelectedRowKeys: selection.mergedSelectedRowKeys,
+    checkboxPropsMap: selection.checkboxPropsMap,
+    isAllSelected: selection.isAllSelected,
+    isIndeterminate: selection.isIndeterminate,
+    triggerSelection: selection.triggerSelection,
+    triggerSelectAll: selection.triggerSelectAll,
+    sorter: pipeline.sorter,
+    setSorter: pipeline.setSorter,
+    getRowKey: getRowKey
+  });
+  var resolvedPagination = pipeline.pagination === false ? {
+    current: 1,
+    pageSize: 10
+  } : pipeline.pagination;
+  var wrappedExpandedRowRender = useMemoizedFn(function (record, index, indent, expanded) {
+    var _a;
+    return _jsx(ExpandedRowContainer, {
+      children: (_a = expandable === null || expandable === void 0 ? void 0 : expandable.expandedRowRender) === null || _a === void 0 ? void 0 : _a.call(expandable, record, index, indent, expanded)
+    });
+  });
+  // Wire kernel's onExpand (triggered by expandRowByClick) to our state
+  var kernelOnExpand = useMemoizedFn(function (expanded, record) {
+    var recordKey = getRowKey(record, dataSource.indexOf(record));
+    expand.onKernelExpand(expanded, record, recordKey);
+  });
+  var mergedExpandable = useMemo(function () {
+    return expandable ? Object.assign(Object.assign({}, expandable), {
+      expandedRowKeys: expand.mergedExpandedRowKeys,
+      expandedRowRender: expandable.expandedRowRender ? wrappedExpandedRowRender : undefined,
+      showExpandColumn: false,
+      onExpand: kernelOnExpand
+    }) : undefined;
+  }, [expandable, expand.mergedExpandedRowKeys, wrappedExpandedRowRender, kernelOnExpand]);
+  void bordered;
+  return _jsxs("div", {
+    className: joinCls("".concat(prefixCls, "-wrapper"), loading && "".concat(prefixCls, "-wrapper--loading")),
+    children: [loading && _jsx("div", {
+      className: "".concat(prefixCls, "-loading-overlay"),
+      children: _jsx(Spinner, {})
+    }), _jsx(InternalRcTable, Object.assign({}, rest, {
+      ref: ref,
+      prefixCls: prefixCls,
+      className: joinCls(cls(), cls(size), cls(variant), className),
+      columns: renderedColumns,
+      data: pipeline.currentDataSource,
+      rowKey: rowKey,
+      emptyText: loading && !dataSource.length ? _jsx("span", {}) : _jsx(TableEmptyState, {
+        empty: empty
+      }),
+      childrenColumnName: childrenColumnName,
+      indentSize: indentSize,
+      expandable: mergedExpandable,
+      onRow: onRow,
+      rowClassName: rowClassName,
+      summary: summary,
+      showHeader: showHeader,
+      tableLayout: tableLayout,
+      components: components,
+      direction: direction,
+      rowHoverable: rowHoverable
+    })), pagination !== false ? _jsx("div", {
+      className: "".concat(prefixCls, "-pagination"),
+      children: _jsx(Pagination, {
+        total: pipeline.total,
+        pageSize: resolvedPagination.pageSize,
+        current: resolvedPagination.current,
+        onChange: function onChange(nextPage, nextPageSize) {
+          return pipeline.setPagination(function (currentPagination) {
+            return Object.assign(Object.assign({}, currentPagination), {
+              current: nextPage,
+              pageSize: nextPageSize
+            });
+          });
+        }
+      })
+    }) : null]
+  });
+};
+var TableBase = /*#__PURE__*/forwardRef(TableInner);
+TableBase.displayName = 'Table';
+export var Table = /*#__PURE__*/memo(TableBase);
+export default Table;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/Table.js","components/src/components/Table/Table.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","forwardRef","memo","useMemo","classnames","joinCls","useMemoizedFn","Pagination","Spinner","InternalRcTable","TABLE_BLOCK","TABLE_DEFAULT_PREFIX","TABLE_DEFAULT_SIZE","TABLE_DEFAULT_VARIANT","useTableDataPipeline","useTableSelection","useTableExpand","useTableColumns","ExpandedRowContainer","TableEmptyState","TableInner","props","ref","_props$className","className","_props$prefixCls","prefixCls","_props$size","size","_props$variant","variant","columns","dataSource","rowKey","empty","bordered","pagination","rowSelection","loading","onChange","childrenColumnName","indentSize","expandable","onRow","rowClassName","summary","showHeader","tableLayout","components","direction","rowHoverable","rest","cls","getRowKey","record","index","_a","pipeline","selection","currentDataSource","expand","renderedColumns","mergedExpandedRowKeys","triggerExpand","mergedSelectedRowKeys","checkboxPropsMap","isAllSelected","isIndeterminate","triggerSelection","triggerSelectAll","sorter","setSorter","resolvedPagination","current","pageSize","wrappedExpandedRowRender","indent","expanded","children","expandedRowRender","kernelOnExpand","recordKey","onKernelExpand","mergedExpandable","assign","expandedRowKeys","undefined","showExpandColumn","onExpand","concat","data","emptyText","total","nextPage","nextPageSize","setPagination","currentPagination","TableBase","displayName","Table"],"mappings":"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","file":"components/Table/Table.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { forwardRef, memo, useMemo } from 'react';\nimport classnames, { joinCls } from '../../utils/classnames';\nimport { useMemoizedFn } from '@1money/hooks';\nimport { Pagination } from '../Pagination';\nimport { Spinner } from '../Spinner';\nimport './style';\nimport { InternalRcTable } from './internal';\nimport { TABLE_BLOCK, TABLE_DEFAULT_PREFIX, TABLE_DEFAULT_SIZE, TABLE_DEFAULT_VARIANT, } from './constants';\nimport { useTableDataPipeline } from './core/useTableDataPipeline';\nimport { useTableSelection } from './core/useTableSelection';\nimport { useTableExpand } from './core/useTableExpand';\nimport { useTableColumns } from './core/useTableColumns';\nimport { ExpandedRowContainer } from './renderers/ExpandedRowContainer';\nimport { TableEmptyState } from './renderers/EmptyState';\nconst TableInner = (props, ref) => {\n    const { className = '', prefixCls = TABLE_DEFAULT_PREFIX, size = TABLE_DEFAULT_SIZE, variant = TABLE_DEFAULT_VARIANT, columns, dataSource, rowKey, empty, bordered, pagination, rowSelection, loading, onChange, childrenColumnName, indentSize, expandable, onRow, rowClassName, summary, showHeader, tableLayout, components, direction, rowHoverable } = props, rest = __rest(props, [\"className\", \"prefixCls\", \"size\", \"variant\", \"columns\", \"dataSource\", \"rowKey\", \"empty\", \"bordered\", \"pagination\", \"rowSelection\", \"loading\", \"onChange\", \"childrenColumnName\", \"indentSize\", \"expandable\", \"onRow\", \"rowClassName\", \"summary\", \"showHeader\", \"tableLayout\", \"components\", \"direction\", \"rowHoverable\"]);\n    const cls = classnames(TABLE_BLOCK);\n    const getRowKey = useMemoizedFn((record, index) => { var _a; return typeof rowKey === 'function' ? rowKey(record) : (_a = record[rowKey !== null && rowKey !== void 0 ? rowKey : 'key']) !== null && _a !== void 0 ? _a : index; });\n    const pipeline = useTableDataPipeline({ columns, dataSource, pagination, onChange });\n    const selection = useTableSelection({\n        rowSelection,\n        dataSource,\n        currentDataSource: pipeline.currentDataSource,\n        getRowKey,\n    });\n    const expand = useTableExpand({ expandable });\n    const renderedColumns = useTableColumns({\n        columns,\n        size,\n        variant,\n        expandable,\n        mergedExpandedRowKeys: expand.mergedExpandedRowKeys,\n        triggerExpand: expand.triggerExpand,\n        rowSelection,\n        mergedSelectedRowKeys: selection.mergedSelectedRowKeys,\n        checkboxPropsMap: selection.checkboxPropsMap,\n        isAllSelected: selection.isAllSelected,\n        isIndeterminate: selection.isIndeterminate,\n        triggerSelection: selection.triggerSelection,\n        triggerSelectAll: selection.triggerSelectAll,\n        sorter: pipeline.sorter,\n        setSorter: pipeline.setSorter,\n        getRowKey,\n    });\n    const resolvedPagination = pipeline.pagination === false\n        ? { current: 1, pageSize: 10 }\n        : pipeline.pagination;\n    const wrappedExpandedRowRender = useMemoizedFn((record, index, indent, expanded) => {\n        var _a;\n        return (_jsx(ExpandedRowContainer, { children: (_a = expandable === null || expandable === void 0 ? void 0 : expandable.expandedRowRender) === null || _a === void 0 ? void 0 : _a.call(expandable, record, index, indent, expanded) }));\n    });\n    // Wire kernel's onExpand (triggered by expandRowByClick) to our state\n    const kernelOnExpand = useMemoizedFn((expanded, record) => {\n        const recordKey = getRowKey(record, dataSource.indexOf(record));\n        expand.onKernelExpand(expanded, record, recordKey);\n    });\n    const mergedExpandable = useMemo(() => expandable\n        ? Object.assign(Object.assign({}, expandable), { expandedRowKeys: expand.mergedExpandedRowKeys, expandedRowRender: expandable.expandedRowRender\n                ? wrappedExpandedRowRender\n                : undefined, showExpandColumn: false, onExpand: kernelOnExpand })\n        : undefined, [expandable, expand.mergedExpandedRowKeys, wrappedExpandedRowRender, kernelOnExpand]);\n    void bordered;\n    return (_jsxs(\"div\", { className: joinCls(`${prefixCls}-wrapper`, loading && `${prefixCls}-wrapper--loading`), children: [loading && (_jsx(\"div\", { className: `${prefixCls}-loading-overlay`, children: _jsx(Spinner, {}) })), _jsx(InternalRcTable, Object.assign({}, rest, { ref: ref, prefixCls: prefixCls, className: joinCls(cls(), cls(size), cls(variant), className), columns: renderedColumns, data: pipeline.currentDataSource, rowKey: rowKey, emptyText: loading && !dataSource.length ? _jsx(\"span\", {}) : _jsx(TableEmptyState, { empty: empty }), childrenColumnName: childrenColumnName, indentSize: indentSize, expandable: mergedExpandable, onRow: onRow, rowClassName: rowClassName, summary: summary, showHeader: showHeader, tableLayout: tableLayout, components: components, direction: direction, rowHoverable: rowHoverable })), pagination !== false ? (_jsx(\"div\", { className: `${prefixCls}-pagination`, children: _jsx(Pagination, { total: pipeline.total, pageSize: resolvedPagination.pageSize, current: resolvedPagination.current, onChange: (nextPage, nextPageSize) => pipeline.setPagination((currentPagination) => (Object.assign(Object.assign({}, currentPagination), { current: nextPage, pageSize: nextPageSize }))) }) })) : null] }));\n};\nconst TableBase = forwardRef(TableInner);\nTableBase.displayName = 'Table';\nexport const Table = memo(TableBase);\nexport default Table;",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Table/VirtualTable.d.ts

@@ -0,0 +1,9 @@
+import { type ReactElement, type Ref } from 'react';
+import type { TableRef, VirtualTableProps } from './interface';
+type ForwardGenericVirtualTable = (<T extends Record<string, any> = Record<string, any>>(props: VirtualTableProps<T> & {
+    ref?: Ref<TableRef>;
+}) => ReactElement | null) & {
+    displayName?: string;
+};
+export declare const VirtualTable: ForwardGenericVirtualTable;
+export default VirtualTable;

package/es/components/Table/VirtualTable.js

@@ -0,0 +1,166 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, memo, useMemo } from 'react';
+import classnames, { joinCls } from '../../utils/classnames';
+import { useMemoizedFn } from '@1money/hooks';
+import { Pagination } from '../Pagination';
+import { Spinner } from '../Spinner';
+import { InternalRcVirtualTable } from './internal';
+import { TABLE_BLOCK, TABLE_DEFAULT_PREFIX, TABLE_DEFAULT_SIZE, TABLE_DEFAULT_VARIANT } from './constants';
+import { useTableDataPipeline } from './core/useTableDataPipeline';
+import { useTableSelection } from './core/useTableSelection';
+import { useTableExpand } from './core/useTableExpand';
+import { useTableColumns } from './core/useTableColumns';
+import { ExpandedRowContainer } from './renderers/ExpandedRowContainer';
+import { TableEmptyState } from './renderers/EmptyState';
+var VirtualTableInner = function VirtualTableInner(props, ref) {
+  var _props$className = props.className,
+    className = _props$className === void 0 ? '' : _props$className,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? TABLE_DEFAULT_PREFIX : _props$prefixCls,
+    _props$size = props.size,
+    size = _props$size === void 0 ? TABLE_DEFAULT_SIZE : _props$size,
+    _props$variant = props.variant,
+    variant = _props$variant === void 0 ? TABLE_DEFAULT_VARIANT : _props$variant,
+    scroll = props.scroll,
+    columns = props.columns,
+    dataSource = props.dataSource,
+    rowKey = props.rowKey,
+    empty = props.empty,
+    bordered = props.bordered,
+    pagination = props.pagination,
+    rowSelection = props.rowSelection,
+    loading = props.loading,
+    onChange = props.onChange,
+    childrenColumnName = props.childrenColumnName,
+    indentSize = props.indentSize,
+    expandable = props.expandable,
+    onRow = props.onRow,
+    rowClassName = props.rowClassName,
+    summary = props.summary,
+    showHeader = props.showHeader,
+    tableLayout = props.tableLayout,
+    components = props.components,
+    direction = props.direction,
+    rowHoverable = props.rowHoverable,
+    rest = __rest(props, ["className", "prefixCls", "size", "variant", "scroll", "columns", "dataSource", "rowKey", "empty", "bordered", "pagination", "rowSelection", "loading", "onChange", "childrenColumnName", "indentSize", "expandable", "onRow", "rowClassName", "summary", "showHeader", "tableLayout", "components", "direction", "rowHoverable"]);
+  var cls = classnames(TABLE_BLOCK);
+  var getRowKey = useMemoizedFn(function (record, index) {
+    var _a;
+    return typeof rowKey === 'function' ? rowKey(record) : (_a = record[rowKey !== null && rowKey !== void 0 ? rowKey : 'key']) !== null && _a !== void 0 ? _a : index;
+  });
+  var pipeline = useTableDataPipeline({
+    columns: columns,
+    dataSource: dataSource,
+    pagination: pagination,
+    onChange: onChange
+  });
+  var selection = useTableSelection({
+    rowSelection: rowSelection,
+    dataSource: dataSource,
+    currentDataSource: pipeline.currentDataSource,
+    getRowKey: getRowKey
+  });
+  var expand = useTableExpand({
+    expandable: expandable
+  });
+  var renderedColumns = useTableColumns({
+    columns: columns,
+    size: size,
+    variant: variant,
+    expandable: expandable,
+    mergedExpandedRowKeys: expand.mergedExpandedRowKeys,
+    triggerExpand: expand.triggerExpand,
+    rowSelection: rowSelection,
+    mergedSelectedRowKeys: selection.mergedSelectedRowKeys,
+    checkboxPropsMap: selection.checkboxPropsMap,
+    isAllSelected: selection.isAllSelected,
+    isIndeterminate: selection.isIndeterminate,
+    triggerSelection: selection.triggerSelection,
+    triggerSelectAll: selection.triggerSelectAll,
+    sorter: pipeline.sorter,
+    setSorter: pipeline.setSorter,
+    getRowKey: getRowKey
+  });
+  var resolvedPagination = pipeline.pagination === false ? {
+    current: 1,
+    pageSize: 10
+  } : pipeline.pagination;
+  var kernelOnExpand = useMemoizedFn(function (expanded, record) {
+    var recordKey = getRowKey(record, dataSource.indexOf(record));
+    expand.onKernelExpand(expanded, record, recordKey);
+  });
+  var mergedExpandable = useMemo(function () {
+    return expandable ? Object.assign(Object.assign({}, expandable), {
+      expandedRowKeys: expand.mergedExpandedRowKeys,
+      expandedRowRender: expandable.expandedRowRender ? function (record, index, indent, expanded) {
+        var _a;
+        return _jsx(ExpandedRowContainer, {
+          children: (_a = expandable.expandedRowRender) === null || _a === void 0 ? void 0 : _a.call(expandable, record, index, indent, expanded)
+        });
+      } : undefined,
+      showExpandColumn: false,
+      onExpand: kernelOnExpand
+    }) : undefined;
+  }, [expandable, expand.mergedExpandedRowKeys, kernelOnExpand]);
+  void bordered;
+  if (typeof scroll.x !== 'number' || typeof scroll.y !== 'number') {
+    console.error('VirtualTable requires numeric scroll.x and scroll.y');
+  }
+  return _jsxs("div", {
+    className: joinCls("".concat(prefixCls, "-wrapper"), loading && "".concat(prefixCls, "-wrapper--loading")),
+    children: [loading && _jsx("div", {
+      className: "".concat(prefixCls, "-loading-overlay"),
+      children: _jsx(Spinner, {})
+    }), _jsx(InternalRcVirtualTable, Object.assign({}, rest, {
+      ref: ref,
+      prefixCls: prefixCls,
+      className: joinCls(cls(), cls(size), cls(variant), className),
+      scroll: scroll,
+      columns: renderedColumns,
+      data: pipeline.currentDataSource,
+      rowKey: rowKey,
+      emptyText: loading && !dataSource.length ? _jsx("span", {}) : _jsx(TableEmptyState, {
+        empty: empty
+      }),
+      childrenColumnName: childrenColumnName,
+      indentSize: indentSize,
+      expandable: mergedExpandable,
+      onRow: onRow,
+      rowClassName: rowClassName,
+      summary: summary,
+      showHeader: showHeader,
+      tableLayout: tableLayout,
+      components: components,
+      direction: direction,
+      rowHoverable: rowHoverable
+    })), pagination !== false ? _jsx("div", {
+      className: "".concat(prefixCls, "-pagination"),
+      children: _jsx(Pagination, {
+        total: pipeline.total,
+        pageSize: resolvedPagination.pageSize,
+        current: resolvedPagination.current,
+        onChange: function onChange(nextPage, nextPageSize) {
+          return pipeline.setPagination(function (currentPagination) {
+            return Object.assign(Object.assign({}, currentPagination), {
+              current: nextPage,
+              pageSize: nextPageSize
+            });
+          });
+        }
+      })
+    }) : null]
+  });
+};
+var VirtualTableBase = /*#__PURE__*/forwardRef(VirtualTableInner);
+VirtualTableBase.displayName = 'VirtualTable';
+export var VirtualTable = /*#__PURE__*/memo(VirtualTableBase);
+export default VirtualTable;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/VirtualTable.js","components/src/components/Table/VirtualTable.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","forwardRef","memo","useMemo","classnames","joinCls","useMemoizedFn","Pagination","Spinner","InternalRcVirtualTable","TABLE_BLOCK","TABLE_DEFAULT_PREFIX","TABLE_DEFAULT_SIZE","TABLE_DEFAULT_VARIANT","useTableDataPipeline","useTableSelection","useTableExpand","useTableColumns","ExpandedRowContainer","TableEmptyState","VirtualTableInner","props","ref","_props$className","className","_props$prefixCls","prefixCls","_props$size","size","_props$variant","variant","scroll","columns","dataSource","rowKey","empty","bordered","pagination","rowSelection","loading","onChange","childrenColumnName","indentSize","expandable","onRow","rowClassName","summary","showHeader","tableLayout","components","direction","rowHoverable","rest","cls","getRowKey","record","index","_a","pipeline","selection","currentDataSource","expand","renderedColumns","mergedExpandedRowKeys","triggerExpand","mergedSelectedRowKeys","checkboxPropsMap","isAllSelected","isIndeterminate","triggerSelection","triggerSelectAll","sorter","setSorter","resolvedPagination","current","pageSize","kernelOnExpand","expanded","recordKey","onKernelExpand","mergedExpandable","assign","expandedRowKeys","expandedRowRender","indent","children","undefined","showExpandColumn","onExpand","x","y","console","error","concat","data","emptyText","total","nextPage","nextPageSize","setPagination","currentPagination","VirtualTableBase","displayName","VirtualTable"],"mappings":"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","file":"components/Table/VirtualTable.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { forwardRef, memo, useMemo } from 'react';\nimport classnames, { joinCls } from '../../utils/classnames';\nimport { useMemoizedFn } from '@1money/hooks';\nimport { Pagination } from '../Pagination';\nimport { Spinner } from '../Spinner';\nimport { InternalRcVirtualTable } from './internal';\nimport { TABLE_BLOCK, TABLE_DEFAULT_PREFIX, TABLE_DEFAULT_SIZE, TABLE_DEFAULT_VARIANT, } from './constants';\nimport { useTableDataPipeline } from './core/useTableDataPipeline';\nimport { useTableSelection } from './core/useTableSelection';\nimport { useTableExpand } from './core/useTableExpand';\nimport { useTableColumns } from './core/useTableColumns';\nimport { ExpandedRowContainer } from './renderers/ExpandedRowContainer';\nimport { TableEmptyState } from './renderers/EmptyState';\nconst VirtualTableInner = (props, ref) => {\n    const { className = '', prefixCls = TABLE_DEFAULT_PREFIX, size = TABLE_DEFAULT_SIZE, variant = TABLE_DEFAULT_VARIANT, scroll, columns, dataSource, rowKey, empty, bordered, pagination, rowSelection, loading, onChange, childrenColumnName, indentSize, expandable, onRow, rowClassName, summary, showHeader, tableLayout, components, direction, rowHoverable } = props, rest = __rest(props, [\"className\", \"prefixCls\", \"size\", \"variant\", \"scroll\", \"columns\", \"dataSource\", \"rowKey\", \"empty\", \"bordered\", \"pagination\", \"rowSelection\", \"loading\", \"onChange\", \"childrenColumnName\", \"indentSize\", \"expandable\", \"onRow\", \"rowClassName\", \"summary\", \"showHeader\", \"tableLayout\", \"components\", \"direction\", \"rowHoverable\"]);\n    const cls = classnames(TABLE_BLOCK);\n    const getRowKey = useMemoizedFn((record, index) => { var _a; return typeof rowKey === 'function' ? rowKey(record) : (_a = record[rowKey !== null && rowKey !== void 0 ? rowKey : 'key']) !== null && _a !== void 0 ? _a : index; });\n    const pipeline = useTableDataPipeline({ columns, dataSource, pagination, onChange });\n    const selection = useTableSelection({\n        rowSelection,\n        dataSource,\n        currentDataSource: pipeline.currentDataSource,\n        getRowKey,\n    });\n    const expand = useTableExpand({ expandable });\n    const renderedColumns = useTableColumns({\n        columns,\n        size,\n        variant,\n        expandable,\n        mergedExpandedRowKeys: expand.mergedExpandedRowKeys,\n        triggerExpand: expand.triggerExpand,\n        rowSelection,\n        mergedSelectedRowKeys: selection.mergedSelectedRowKeys,\n        checkboxPropsMap: selection.checkboxPropsMap,\n        isAllSelected: selection.isAllSelected,\n        isIndeterminate: selection.isIndeterminate,\n        triggerSelection: selection.triggerSelection,\n        triggerSelectAll: selection.triggerSelectAll,\n        sorter: pipeline.sorter,\n        setSorter: pipeline.setSorter,\n        getRowKey,\n    });\n    const resolvedPagination = pipeline.pagination === false\n        ? { current: 1, pageSize: 10 }\n        : pipeline.pagination;\n    const kernelOnExpand = useMemoizedFn((expanded, record) => {\n        const recordKey = getRowKey(record, dataSource.indexOf(record));\n        expand.onKernelExpand(expanded, record, recordKey);\n    });\n    const mergedExpandable = useMemo(() => expandable\n        ? Object.assign(Object.assign({}, expandable), { expandedRowKeys: expand.mergedExpandedRowKeys, expandedRowRender: expandable.expandedRowRender\n                ? (record, index, indent, expanded) => {\n                    var _a;\n                    return (_jsx(ExpandedRowContainer, { children: (_a = expandable.expandedRowRender) === null || _a === void 0 ? void 0 : _a.call(expandable, record, index, indent, expanded) }));\n                }\n                : undefined, showExpandColumn: false, onExpand: kernelOnExpand })\n        : undefined, [expandable, expand.mergedExpandedRowKeys, kernelOnExpand]);\n    void bordered;\n    if (typeof scroll.x !== 'number' || typeof scroll.y !== 'number') {\n        console.error('VirtualTable requires numeric scroll.x and scroll.y');\n    }\n    return (_jsxs(\"div\", { className: joinCls(`${prefixCls}-wrapper`, loading && `${prefixCls}-wrapper--loading`), children: [loading && (_jsx(\"div\", { className: `${prefixCls}-loading-overlay`, children: _jsx(Spinner, {}) })), _jsx(InternalRcVirtualTable, Object.assign({}, rest, { ref: ref, prefixCls: prefixCls, className: joinCls(cls(), cls(size), cls(variant), className), scroll: scroll, columns: renderedColumns, data: pipeline.currentDataSource, rowKey: rowKey, emptyText: loading && !dataSource.length ? _jsx(\"span\", {}) : _jsx(TableEmptyState, { empty: empty }), childrenColumnName: childrenColumnName, indentSize: indentSize, expandable: mergedExpandable, onRow: onRow, rowClassName: rowClassName, summary: summary, showHeader: showHeader, tableLayout: tableLayout, components: components, direction: direction, rowHoverable: rowHoverable })), pagination !== false ? (_jsx(\"div\", { className: `${prefixCls}-pagination`, children: _jsx(Pagination, { total: pipeline.total, pageSize: resolvedPagination.pageSize, current: resolvedPagination.current, onChange: (nextPage, nextPageSize) => pipeline.setPagination((currentPagination) => (Object.assign(Object.assign({}, currentPagination), { current: nextPage, pageSize: nextPageSize }))) }) })) : null] }));\n};\nconst VirtualTableBase = forwardRef(VirtualTableInner);\nVirtualTableBase.displayName = 'VirtualTable';\nexport const VirtualTable = memo(VirtualTableBase);\nexport default VirtualTable;",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Table/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const TABLE_DEFAULT_PREFIX = "om-react-ui-table";
+export declare const TABLE_BLOCK = "table";
+export declare const TABLE_DEFAULT_SIZE = "large";
+export declare const TABLE_DEFAULT_VARIANT = "fill";

package/es/components/Table/constants.js

@@ -0,0 +1,5 @@
+export var TABLE_DEFAULT_PREFIX = 'om-react-ui-table';
+export var TABLE_BLOCK = 'table';
+export var TABLE_DEFAULT_SIZE = 'large';
+export var TABLE_DEFAULT_VARIANT = 'fill';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvVGFibGUvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbIlRBQkxFX0RFRkFVTFRfUFJFRklYIiwiVEFCTEVfQkxPQ0siLCJUQUJMRV9ERUZBVUxUX1NJWkUiLCJUQUJMRV9ERUZBVUxUX1ZBUklBTlQiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sSUFBTUEsb0JBQW9CLEdBQUcsbUJBQW1CO0FBQ3ZELE9BQU8sSUFBTUMsV0FBVyxHQUFHLE9BQU87QUFDbEMsT0FBTyxJQUFNQyxrQkFBa0IsR0FBRyxPQUFPO0FBQ3pDLE9BQU8sSUFBTUMscUJBQXFCLEdBQUcsTUFBTSIsImZpbGUiOiJjb21wb25lbnRzL1RhYmxlL2NvbnN0YW50cy5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/components/Table/core/useTableColumns.d.ts

@@ -0,0 +1,34 @@
+import { type Key } from 'react';
+import type { TableColumnType, TableExpandableConfig, TableRowSelection, TableSize, TableSortOrder, TableVariant } from '../interface';
+import type { TableSorterState } from './useTableDataPipeline';
+interface UseTableColumnsConfig<T> {
+    columns: TableColumnType<T>[];
+    size: TableSize;
+    variant: TableVariant;
+    expandable?: TableExpandableConfig<T>;
+    mergedExpandedRowKeys: Key[];
+    triggerExpand: (key: Key, record: T) => void;
+    rowSelection?: TableRowSelection<T>;
+    mergedSelectedRowKeys: Key[];
+    checkboxPropsMap: Map<Key, Partial<{
+        disabled: boolean;
+    }>>;
+    isAllSelected: boolean;
+    isIndeterminate: boolean;
+    triggerSelection: (key: Key) => void;
+    triggerSelectAll: () => void;
+    sorter: TableSorterState;
+    setSorter: (updater: {
+        columnKey?: Key;
+        order?: TableSortOrder;
+    } | ((current: {
+        columnKey?: Key;
+        order?: TableSortOrder;
+    }) => {
+        columnKey?: Key;
+        order?: TableSortOrder;
+    })) => void;
+    getRowKey: (record: T, index: number) => Key;
+}
+export declare function useTableColumns<T>(config: UseTableColumnsConfig<T>): TableColumnType<T>[];
+export {};