@infomaximum/ui-kit 0.15.9 → 0.16.0

package/dist/components/Table/forStories/example_5.d.ts

@@ -0,0 +1,9 @@
+import { DefaultRecord, TableProps } from '../Table.types';
+interface DataType extends DefaultRecord {
+    name: string;
+    age?: number;
+    address?: string;
+}
+export declare const columns: TableProps<DataType>["columns"];
+export declare const data: readonly DataType[];
+export {};

package/dist/components/Table/forStories/example_6.d.ts

@@ -0,0 +1,9 @@
+import { DefaultRecord, TableProps } from '../Table.types';
+interface DataType extends DefaultRecord {
+    name: string;
+    age: number;
+    address: string;
+}
+export declare const columns: TableProps<DataType>["columns"];
+export declare const data: DataType[];
+export {};

package/dist/components/Table/forStories/example_7.d.ts

@@ -0,0 +1,9 @@
+import { DefaultRecord, TableProps } from '../Table.types';
+interface DataType extends DefaultRecord {
+    name: string;
+    age: number;
+    address: string;
+}
+export declare const columns: TableProps<DataType>["columns"];
+export declare const data: readonly DataType[];
+export {};

package/dist/components/Table/forStories/index.d.ts

@@ -0,0 +1,7 @@
+export { columns as columns1, data as data1 } from './example_1';
+export { columns as columns2, data as data2, getCheckboxProps as getCheckboxProps2, } from './example_2';
+export { columns as columns3, data as data3 } from './example_3';
+export { columns as columns4 } from './example_4';
+export { columns as columns5, data as data5 } from './example_5';
+export { columns as columns6, data as data6 } from './example_6';
+export { columns as columns7, data as data7 } from './example_7';

package/dist/components/Table/hooks/useBodyCellRender/index.d.ts

@@ -0,0 +1 @@
+export { useBodyCellRender } from './useBodyCellRender';

package/dist/components/Table/hooks/useBodyCellRender/useBodyCellRender.d.ts

@@ -0,0 +1,4 @@
+import { UseBodyCellRenderOptions } from './useBodyCellRender.types';
+export declare const useBodyCellRender: <Record>(options: UseBodyCellRenderOptions<Record>) => {
+    children: any;
+};

package/dist/components/Table/hooks/useBodyCellRender/useBodyCellRender.js

@@ -0,0 +1,27 @@
+import { get } from "lodash-es";
+import { useMemo } from "react";
+const useBodyCellRender = (options) => {
+  const {
+    record,
+    dataIndex,
+    renderIndex,
+    render
+  } = options;
+  const children = useMemo(() => {
+    let value;
+    if (dataIndex) {
+      value = get(record, dataIndex);
+    }
+    let result = value;
+    if (render) {
+      result = render(value, record, renderIndex);
+    }
+    return result;
+  }, [record, dataIndex, renderIndex, render]);
+  return {
+    children
+  };
+};
+export {
+  useBodyCellRender
+};

package/dist/components/Table/hooks/useBodyCellRender/useBodyCellRender.types.d.ts

@@ -0,0 +1,7 @@
+import { BodyCellProps } from '../../components/Body/components/BodyCell/BodyCell.types';
+export interface UseBodyCellRenderOptions<Record> {
+    record: BodyCellProps<Record>["record"];
+    dataIndex: BodyCellProps<Record>["column"]["dataIndex"];
+    renderIndex: BodyCellProps<Record>["renderIndex"];
+    render: BodyCellProps<Record>["column"]["render"];
+}

package/dist/components/Table/hooks/useBodyFlattenData/index.d.ts

@@ -0,0 +1 @@
+export { useBodyFlattenData } from './useBodyFlattenData';

package/dist/components/Table/hooks/useBodyFlattenData/useBodyFlattenData.d.ts

@@ -0,0 +1,5 @@
+import { FlattedData, UseBodyFlattenDataOptions } from './useBodyFlattenData.types';
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const useBodyFlattenData: <Record extends DefaultRecord>(options: UseBodyFlattenDataOptions<Record>) => {
+    flattedData: FlattedData<Record>[];
+};

package/dist/components/Table/hooks/useBodyFlattenData/useBodyFlattenData.js

@@ -0,0 +1,31 @@
+import { useMemo } from "react";
+import { fillRecords } from "./useBodyFlattenData.utils.js";
+import { getRowKey } from "../../utils/getRowKey/getRowKey.js";
+const useBodyFlattenData = (options) => {
+  const {
+    data,
+    expandedKeys
+  } = options;
+  const flattedData = useMemo(() => {
+    if (expandedKeys.size) {
+      const list = [];
+      for (let i = 0; i < data.length; i += 1) {
+        const record = data[i];
+        fillRecords(list, record, 0, expandedKeys, i);
+      }
+      return list;
+    }
+    return data.map((item, index) => ({
+      record: item,
+      indent: 0,
+      index,
+      rowKey: getRowKey(item)
+    }));
+  }, [data, expandedKeys]);
+  return {
+    flattedData
+  };
+};
+export {
+  useBodyFlattenData
+};

package/dist/components/Table/hooks/useBodyFlattenData/useBodyFlattenData.types.d.ts

@@ -0,0 +1,11 @@
+import { Key } from 'components/Table/Table.types';
+export interface UseBodyFlattenDataOptions<Record> {
+    data: Record[];
+    expandedKeys: Set<Key>;
+}
+export interface FlattedData<Record> {
+    record: Record;
+    indent: number;
+    index: number;
+    rowKey: Key;
+}

package/dist/components/Table/hooks/useBodyFlattenData/useBodyFlattenData.utils.d.ts

@@ -0,0 +1,3 @@
+import { DefaultRecord, Key } from 'components/Table/Table.types';
+import { FlattedData } from './useBodyFlattenData.types';
+export declare function fillRecords<Record extends DefaultRecord>(list: FlattedData<Record>[], record: Record, indent: number, expandedKeys: Set<Key>, index: number): void;

package/dist/components/Table/hooks/useBodyFlattenData/useBodyFlattenData.utils.js

@@ -0,0 +1,19 @@
+import { getRowKey } from "../../utils/getRowKey/getRowKey.js";
+function fillRecords(list, record, indent, expandedKeys, index) {
+  const key = getRowKey(record);
+  list.push({
+    record,
+    indent,
+    index,
+    rowKey: key
+  });
+  const expanded = expandedKeys.has(key);
+  if (record && Array.isArray(record.children) && expanded) {
+    for (let i = 0; i < record.children.length; i += 1) {
+      fillRecords(list, record.children[i], indent + 1, expandedKeys, i);
+    }
+  }
+}
+export {
+  fillRecords
+};

package/dist/components/Table/hooks/useCellFixedInfo/index.d.ts

@@ -0,0 +1,3 @@
+export { useCellFixedInfo } from './useCellFixedInfo';
+export type { StickyOffsets } from './useCellFixedInfo.types';
+export { getFixedCellStyle } from './useCellFixedInfo.styles';

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.d.ts

@@ -0,0 +1,12 @@
+import { UseCellFixedInfoOptions } from './useCellFixedInfo.types';
+export declare const useCellFixedInfo: (options: UseCellFixedInfoOptions) => {
+    isFixStart: boolean;
+    isFixEnd: boolean;
+    fixStart: number | null;
+    fixEnd: number | null;
+    zIndexReverse: number;
+    fixedStartShadow: boolean;
+    fixedEndShadow: boolean;
+    showFixStartShadow: boolean;
+    showFixEndShadow: boolean;
+};

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.js

@@ -0,0 +1,117 @@
+import { useState, useRef } from "react";
+import { isNumber } from "lodash-es";
+import { getCellFixedMinimalInfo, getCellFixedInfo } from "./useCellFixedInfo.utils.js";
+import { useTableContext } from "../../contexts/tableContext/useTableContext/useTableContext.js";
+import { useSubscribe } from "../../features/typedEventBus/hooks.js";
+import { updateRefValue, getRefValue } from "../../utils/ref/ref.js";
+const useCellFixedInfo = (options) => {
+  const {
+    colStart,
+    colEnd
+  } = options;
+  const {
+    flattedColumns,
+    isAllColumnsFixedStart
+  } = useTableContext();
+  const [fixStart, setFixStart] = useState(null);
+  const [fixEnd, setFixEnd] = useState(null);
+  const isFixStart = isNumber(fixStart) && !isAllColumnsFixedStart;
+  const isFixEnd = isNumber(fixEnd) && !isAllColumnsFixedStart;
+  const [fixedStartShadow, setFixedStartShadow] = useState(false);
+  const [fixedEndShadow, setFixedEndShadow] = useState(false);
+  const [zIndexReverse, setZIndexReverse] = useState(0);
+  const [showFixStartShadow, setShowFixStartShadow] = useState(false);
+  const [showFixEndShadow, setShowFixEndShadow] = useState(false);
+  const infoRef = useRef({
+    fixStart: null,
+    fixEnd: null,
+    fixedStartShadow: false,
+    fixedEndShadow: false,
+    offsetFixedStartShadow: 0,
+    offsetFixedEndShadow: 0,
+    zIndex: 0,
+    zIndexReverse: 0,
+    showStartShadow: false,
+    showEndShadow: false
+  });
+  const {
+    skipSubscribe
+  } = getCellFixedMinimalInfo(colStart, colEnd, flattedColumns);
+  useSubscribe("table-visual-params:change", (value) => {
+    const {
+      measureCellsInfo,
+      horizontalScrollPositionRange
+    } = value;
+    if (measureCellsInfo) {
+      const {
+        fixStart: fixStart3,
+        fixEnd: fixEnd3,
+        fixedStartShadow: fixedStartShadow3,
+        fixedEndShadow: fixedEndShadow3,
+        offsetFixedStartShadow,
+        offsetFixedEndShadow,
+        zIndex,
+        zIndexReverse: zIndexReverse3
+      } = getCellFixedInfo(colStart, colEnd, flattedColumns, measureCellsInfo);
+      updateRefValue(infoRef, {
+        fixStart: fixStart3,
+        fixEnd: fixEnd3,
+        fixedStartShadow: fixedStartShadow3,
+        fixedEndShadow: fixedEndShadow3,
+        offsetFixedStartShadow,
+        offsetFixedEndShadow,
+        zIndex,
+        zIndexReverse: zIndexReverse3
+      });
+    }
+    if (horizontalScrollPositionRange) {
+      const [absScroll, scrollWidth] = horizontalScrollPositionRange;
+      const {
+        fixStart: fixStart3,
+        fixEnd: fixEnd3,
+        fixedStartShadow: fixedStartShadow3,
+        fixedEndShadow: fixedEndShadow3,
+        offsetFixedStartShadow,
+        offsetFixedEndShadow
+      } = getRefValue(infoRef);
+      const isFixStart2 = isNumber(fixStart3) && !isAllColumnsFixedStart;
+      const isFixEnd2 = isNumber(fixEnd3) && !isAllColumnsFixedStart;
+      const showStartShadow2 = Number(isFixStart2 && fixedStartShadow3 && absScroll) - offsetFixedStartShadow >= 1;
+      const showEndShadow2 = Number(isFixEnd2 && fixedEndShadow3 && scrollWidth - absScroll) - offsetFixedEndShadow > 1;
+      updateRefValue(infoRef, {
+        showStartShadow: showStartShadow2,
+        showEndShadow: showEndShadow2
+      });
+    }
+    const {
+      fixStart: fixStart2,
+      fixEnd: fixEnd2,
+      fixedStartShadow: fixedStartShadow2,
+      fixedEndShadow: fixedEndShadow2,
+      zIndexReverse: zIndexReverse2,
+      showStartShadow,
+      showEndShadow
+    } = getRefValue(infoRef);
+    setFixStart(fixStart2);
+    setFixEnd(fixEnd2);
+    setFixedStartShadow(fixedStartShadow2);
+    setFixedEndShadow(fixedEndShadow2);
+    setZIndexReverse(zIndexReverse2);
+    setShowFixStartShadow(showStartShadow);
+    setShowFixEndShadow(showEndShadow);
+  }, skipSubscribe, [colStart, colEnd, isAllColumnsFixedStart, flattedColumns], true);
+  return {
+    isFixStart,
+    isFixEnd,
+    fixStart,
+    fixEnd,
+    zIndexReverse,
+    fixedStartShadow,
+    fixedEndShadow,
+    showFixStartShadow,
+    showFixEndShadow
+  };
+};
+export {
+  useCellFixedInfo
+};

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.styles.d.ts

@@ -0,0 +1,26 @@
+import { useCellFixedInfo } from './useCellFixedInfo';
+import { Key } from 'components/Table/Table.types';
+export declare const getFixedCellStyle: ({ columnKey, isFixStart, isFixEnd, fixStart, fixEnd, zIndexReverse, fixedStartShadow, fixedEndShadow, showFixStartShadow, showFixEndShadow, }: ReturnType<typeof useCellFixedInfo> & {
+    columnKey: Key;
+}) => ({
+    readonly position: "relative" | "sticky" | undefined;
+    readonly zIndex: number | undefined;
+    readonly insetInlineStart: number | undefined;
+    readonly insetInlineEnd: number | undefined;
+    readonly "::after"?: undefined;
+} | {
+    readonly "::after": {
+        readonly content: "''";
+        readonly position: "absolute";
+        readonly top: 0;
+        readonly bottom: -1;
+        readonly insetInlineStart: "100%" | undefined;
+        readonly insetInlineEnd: "100%" | undefined;
+        readonly width: 10;
+        readonly boxShadow: "inset 10px 0 8px -8px rgba(5, 5, 5, 0.06)" | "inset -10px 0 8px -8px rgba(5, 5, 5, 0.06)" | undefined;
+    };
+    readonly position?: undefined;
+    readonly zIndex?: undefined;
+    readonly insetInlineStart?: undefined;
+    readonly insetInlineEnd?: undefined;
+} | undefined)[];

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.styles.js

@@ -0,0 +1,33 @@
+import { isNumber } from "lodash-es";
+import { selectionColumnKey } from "../../features/tableRowSelection/utils/const.js";
+const getFixedCellStyle = ({
+  columnKey,
+  isFixStart,
+  isFixEnd,
+  fixStart,
+  fixEnd,
+  zIndexReverse,
+  fixedStartShadow,
+  fixedEndShadow,
+  showFixStartShadow,
+  showFixEndShadow
+}) => [{
+  position: isFixStart || isFixEnd ? "sticky" : columnKey === selectionColumnKey ? "relative" : void 0,
+  zIndex: (isFixStart || isFixEnd) && zIndexReverse !== 0 ? zIndexReverse + 2 : void 0,
+  insetInlineStart: isFixStart && isNumber(fixStart) ? fixStart : void 0,
+  insetInlineEnd: isFixEnd && isNumber(fixEnd) ? fixEnd : void 0
+}, fixedStartShadow || fixedEndShadow ? {
+  "::after": {
+    content: "''",
+    position: "absolute",
+    top: 0,
+    bottom: -1,
+    insetInlineStart: fixedStartShadow ? "100%" : void 0,
+    insetInlineEnd: fixedEndShadow ? "100%" : void 0,
+    width: 10,
+    boxShadow: showFixStartShadow ? "inset 10px 0 8px -8px rgba(5, 5, 5, 0.06)" : showFixEndShadow ? "inset -10px 0 8px -8px rgba(5, 5, 5, 0.06)" : void 0
+  }
+} : void 0];
+export {
+  getFixedCellStyle
+};

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.types.d.ts

@@ -0,0 +1,19 @@
+export interface UseCellFixedInfoOptions {
+    colStart: number;
+    colEnd: number;
+}
+export interface FixedInfo {
+    fixStart: number | null;
+    fixEnd: number | null;
+    fixedStartShadow: boolean;
+    fixedEndShadow: boolean;
+    offsetFixedStartShadow: number;
+    offsetFixedEndShadow: number;
+    zIndex: number;
+    zIndexReverse: number;
+}
+export interface StickyOffsets {
+    start: readonly number[];
+    end: readonly number[];
+    widths: readonly number[];
+}

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.utils.d.ts

@@ -0,0 +1,9 @@
+import { FixedInfo, StickyOffsets } from './useCellFixedInfo.types';
+export declare function getCellFixedMinimalInfo(colStart: number, colEnd: number, columns: readonly {
+    fixed?: "start" | "end";
+}[]): {
+    skipSubscribe: boolean;
+};
+export declare function getCellFixedInfo(colStart: number, colEnd: number, columns: readonly {
+    fixed?: "start" | "end";
+}[], stickyOffsets: StickyOffsets): FixedInfo;

package/dist/components/Table/hooks/useCellFixedInfo/useCellFixedInfo.utils.js

@@ -0,0 +1,75 @@
+function isFixedStart(column) {
+  return column.fixed === "start";
+}
+function isFixedEnd(column) {
+  return column.fixed === "end";
+}
+function getCellFixedMinimalInfo(colStart, colEnd, columns) {
+  const startColumn = columns[colStart] || {};
+  const endColumn = columns[colEnd] || {};
+  let fixStart = false;
+  let fixEnd = false;
+  if (isFixedStart(startColumn) && isFixedStart(endColumn)) {
+    fixStart = true;
+  } else if (isFixedEnd(endColumn) && isFixedEnd(startColumn)) {
+    fixEnd = true;
+  }
+  return {
+    skipSubscribe: !(fixStart || fixEnd)
+  };
+}
+function getCellFixedInfo(colStart, colEnd, columns, stickyOffsets) {
+  const startColumn = columns[colStart] || {};
+  const endColumn = columns[colEnd] || {};
+  let fixStart = null;
+  let fixEnd = null;
+  if (isFixedStart(startColumn) && isFixedStart(endColumn)) {
+    fixStart = stickyOffsets.start[colStart];
+  } else if (isFixedEnd(endColumn) && isFixedEnd(startColumn)) {
+    fixEnd = stickyOffsets.end[colEnd];
+  }
+  let fixedStartShadow = false;
+  let fixedEndShadow = false;
+  let zIndex = 0;
+  let zIndexReverse = 0;
+  if (fixStart !== null) {
+    fixedStartShadow = !columns[colEnd + 1] || !isFixedStart(columns[colEnd + 1]);
+    zIndex = columns.length * 2 - colStart;
+    zIndexReverse = columns.length + colStart;
+  }
+  if (fixEnd !== null) {
+    fixedEndShadow = !columns[colStart - 1] || !isFixedEnd(columns[colStart - 1]);
+    zIndex = colEnd;
+    zIndexReverse = columns.length - colEnd;
+  }
+  let offsetFixedStartShadow = 0;
+  let offsetFixedEndShadow = 0;
+  if (fixedStartShadow) {
+    for (let i = 0; i < colStart; i += 1) {
+      if (!isFixedStart(columns[i])) {
+        offsetFixedStartShadow += stickyOffsets.widths[i] || 0;
+      }
+    }
+  }
+  if (fixedEndShadow) {
+    for (let i = columns.length - 1; i > colEnd; i -= 1) {
+      if (!isFixedEnd(columns[i])) {
+        offsetFixedEndShadow += stickyOffsets.widths[i] || 0;
+      }
+    }
+  }
+  return {
+    fixStart,
+    fixEnd,
+    fixedStartShadow,
+    fixedEndShadow,
+    offsetFixedStartShadow,
+    offsetFixedEndShadow,
+    zIndex,
+    zIndexReverse
+  };
+}
+export {
+  getCellFixedInfo,
+  getCellFixedMinimalInfo
+};

package/dist/components/Table/hooks/useCellHover/index.d.ts

@@ -0,0 +1 @@
+export { useCellHover } from './useCellHover';

package/dist/components/Table/hooks/useCellHover/useCellHover.d.ts

@@ -0,0 +1,8 @@
+import { UseCellHoverOptions } from './useCellHover.types';
+export declare const useCellHover: (options: UseCellHoverOptions) => {
+    isHovered: boolean;
+    emitCellHover: (payload: {
+        start: number;
+        end: number;
+    }) => void;
+};

package/dist/components/Table/hooks/useCellHover/useCellHover.js

@@ -0,0 +1,34 @@
+import { useRef, useState } from "react";
+import { isInHoverRange } from "./useCellHover.utils.js";
+import { useSubscribe, useEmitter } from "../../features/typedEventBus/hooks.js";
+const useCellHover = (options) => {
+  const {
+    index,
+    rowSpan,
+    skipSubscribe
+  } = options;
+  const hoverIdRef = useRef(0);
+  const [isHovered, setHovered] = useState(false);
+  useSubscribe("cell:hover", (value) => {
+    const {
+      start,
+      end
+    } = value;
+    hoverIdRef.current += 1;
+    const currentId = hoverIdRef.current;
+    queueMicrotask(() => {
+      if (currentId === hoverIdRef.current) {
+        const val = isInHoverRange(index, rowSpan, start, end);
+        setHovered(val);
+      }
+    });
+  }, skipSubscribe, [index, rowSpan]);
+  const emitCellHover = useEmitter("cell:hover");
+  return {
+    isHovered,
+    emitCellHover
+  };
+};
+export {
+  useCellHover
+};

package/dist/components/Table/hooks/useCellHover/useCellHover.types.d.ts

@@ -0,0 +1,5 @@
+export interface UseCellHoverOptions {
+    index: number;
+    rowSpan: number;
+    skipSubscribe?: boolean;
+}

package/dist/components/Table/hooks/useCellHover/useCellHover.utils.d.ts

@@ -0,0 +1 @@
+export declare const isInHoverRange: (cellStartRow: number, cellRowSpan: number, startRow: number, endRow: number) => boolean;

package/dist/components/Table/hooks/useCellHover/useCellHover.utils.js

@@ -0,0 +1,7 @@
+const isInHoverRange = (cellStartRow, cellRowSpan, startRow, endRow) => {
+  const cellEndRow = cellStartRow + cellRowSpan - 1;
+  return cellStartRow <= endRow && cellEndRow >= startRow;
+};
+export {
+  isInHoverRange
+};

package/dist/components/Table/hooks/useTableColumns/index.d.ts

@@ -0,0 +1 @@
+export { useTableColumns } from './useTableColumns';

package/dist/components/Table/hooks/useTableColumns/useTableColumns.d.ts

@@ -0,0 +1,7 @@
+import { UseTableColumnsOptions } from './useTableColumns.types';
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const useTableColumns: <Record extends DefaultRecord>(options: UseTableColumnsOptions<Record>) => {
+    columns: (import('../../interfaces/tableColumns.types').ColumnWithChildren<Record> | import('../../interfaces/tableColumns.types').Column<Record>)[];
+    flattedColumns: import('../../interfaces/tableColumns.types').Column<Record>[];
+    isAllColumnsFixedStart: boolean;
+};

package/dist/components/Table/hooks/useTableColumns/useTableColumns.js

@@ -0,0 +1,39 @@
+import { useMemo } from "react";
+import { flatColumns } from "./useTableColumns.utils.js";
+import { useTransformColumns } from "../../features/tableRowSelection/hooks/useTransformColumns/useTransformColumns.js";
+import { useTransformColumns as useTransformColumns$1 } from "../../features/tableSort/hooks/useTransformColumns/useTransformColumns.js";
+const emptyColumnKey = "__EMPTY_COLUMN";
+const useTableColumns = (options) => {
+  const {
+    columns: columnsProp,
+    rowSelection
+  } = options;
+  const {
+    transformColumns: rowSelectionTransformColumns
+  } = useTransformColumns({
+    rowSelection
+  });
+  const {
+    transformColumns: sorterTransformColumns
+  } = useTransformColumns$1();
+  const columns = useMemo(() => {
+    const transformers = [sorterTransformColumns, rowSelectionTransformColumns];
+    const resultColumns = transformers.reduce((transformedColumns, transformer) => transformer(transformedColumns), [...columnsProp]);
+    if (!resultColumns.length) {
+      resultColumns.push({
+        key: emptyColumnKey
+      });
+    }
+    return resultColumns;
+  }, [columnsProp, rowSelectionTransformColumns, sorterTransformColumns]);
+  const flattedColumns = useMemo(() => flatColumns(columns), [columns]);
+  const isAllColumnsFixedStart = useMemo(() => flattedColumns.every((col) => col.fixed === "start"), [flattedColumns]);
+  return {
+    columns,
+    flattedColumns,
+    isAllColumnsFixedStart
+  };
+};
+export {
+  useTableColumns
+};

package/dist/components/Table/hooks/useTableColumns/useTableColumns.types.d.ts

@@ -0,0 +1,4 @@
+import { UseTransformColumnsOptions } from 'components/Table/features/tableRowSelection';
+import { DefaultRecord, TableProps } from '../../Table.types';
+export interface UseTableColumnsOptions<Record extends DefaultRecord> extends Pick<TableProps<Record>, "columns">, UseTransformColumnsOptions<Record> {
+}

package/dist/components/Table/hooks/useTableColumns/useTableColumns.utils.d.ts

@@ -0,0 +1,2 @@
+import { Column, Columns } from 'components/Table/interfaces/tableColumns.types';
+export declare const flatColumns: <Record>(columns: Columns<Record>) => Column<Record>[];

package/dist/components/Table/hooks/useTableColumns/useTableColumns.utils.js

@@ -0,0 +1,24 @@
+const flatColumns = (columns) => {
+  return columns.reduce((acc, column) => {
+    const {
+      fixed
+    } = column;
+    const subColumns = "children" in column ? column.children : [];
+    if (subColumns.length > 0) {
+      return [...acc, ...flatColumns(subColumns).map((subColumn) => {
+        const clonedSubColumn = {
+          ...subColumn
+        };
+        const resultFixed = subColumn.fixed ?? fixed;
+        if (resultFixed) {
+          clonedSubColumn.fixed = resultFixed;
+        }
+        return clonedSubColumn;
+      })];
+    }
+    return [...acc, column];
+  }, []);
+};
+export {
+  flatColumns
+};

package/dist/components/Table/hooks/useTableComponents/index.d.ts

@@ -0,0 +1 @@
+export { useTableComponents } from './useTableComponents';

package/dist/components/Table/hooks/useTableComponents/useTableComponents.d.ts

@@ -0,0 +1,6 @@
+import { PropertyPath } from 'lodash-es';
+import { UseTableComponentsOptions } from './useTableComponents.types';
+import { CustomizedComponent } from 'components/Table/interfaces/tableComponents.types';
+export declare const useTableComponents: (options: UseTableComponentsOptions) => {
+    getComponent: <T extends CustomizedComponent>(path: PropertyPath, defaultComponent: T) => T;
+};

package/dist/components/Table/hooks/useTableComponents/useTableComponents.js

@@ -0,0 +1,14 @@
+import { useCallback } from "react";
+import { get } from "lodash-es";
+const useTableComponents = (options) => {
+  const {
+    components
+  } = options;
+  const getComponent = useCallback((path, defaultComponent) => get(components, path, defaultComponent), [components]);
+  return {
+    getComponent
+  };
+};
+export {
+  useTableComponents
+};

package/dist/components/Table/hooks/useTableComponents/useTableComponents.types.d.ts

@@ -0,0 +1,3 @@
+import { TableProps } from '../../Table.types';
+export interface UseTableComponentsOptions extends Pick<TableProps, "components"> {
+}