@infomaximum/ui-kit 0.15.8 → 0.16.0

package/dist/components/Table/features/tableSort/components/HeaderCellWithSort/HeaderCellWithSort.types.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+import { DefaultRecord } from 'components/Table/Table.types';
+import { HeaderCell } from 'components/Table/components/Header/Header.types';
+export interface HeaderCellWithSortProps<Record extends DefaultRecord> extends PropsWithChildren {
+    cell: HeaderCell<Record>;
+}

package/dist/components/Table/features/tableSort/components/SortButton/SortButton.d.ts

@@ -0,0 +1,2 @@
+import { SortButtonProps } from './SortButton.types';
+export declare const SortButton: <Record>(props: SortButtonProps<Record>) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/components/Table/features/tableSort/components/SortButton/SortButton.js

@@ -0,0 +1,27 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import { sortButtonStyle, getAscendArrowStyle, getDescendArrowStyle } from "./SortButton.styles.js";
+import { useTheme } from "../../../../../../hooks/useTheme/useTheme.js";
+import { useSortState } from "../../hooks/useSortState/useSortState.js";
+import { ArrowFilled } from "../../icons/ArrowFilled.js";
+const SortButtonComponent = (props) => {
+  const {
+    column
+  } = props;
+  const theme = useTheme();
+  const {
+    sortOrder,
+    sortDirections
+  } = useSortState({
+    column
+  });
+  const hasAscendOrder = sortDirections.includes("ascend");
+  const hasDescendOrder = sortDirections.includes("descend");
+  return /* @__PURE__ */ jsxs("span", { className: "column-sorter-inner", "aria-hidden": "true", css: sortButtonStyle(theme), children: [
+    hasAscendOrder && /* @__PURE__ */ jsx(ArrowFilled, { css: getAscendArrowStyle(sortOrder)(theme) }),
+    hasDescendOrder && /* @__PURE__ */ jsx(ArrowFilled, { css: getDescendArrowStyle(sortOrder)(theme) })
+  ] });
+};
+const SortButton = SortButtonComponent;
+export {
+  SortButton
+};

package/dist/components/Table/features/tableSort/components/SortButton/SortButton.styles.d.ts

@@ -0,0 +1,17 @@
+import { Theme } from 'themes';
+import { SortOrder } from '../../types';
+export declare const sortButtonStyle: (theme: Theme) => {
+    readonly display: "inline-flex";
+    readonly flexDirection: "column";
+    readonly rowGap: 2;
+    readonly paddingInline: 3.5;
+    readonly paddingBlock: 4;
+    readonly color: `rgba(${number}, ${number}, ${number}, 0.3)`;
+};
+export declare const getAscendArrowStyle: (sortOrder: SortOrder) => (theme: Theme) => {
+    color: "#0CB3B3" | undefined;
+};
+export declare const getDescendArrowStyle: (sortOrder: SortOrder) => (theme: Theme) => {
+    color: "#0CB3B3" | undefined;
+    transform: string;
+};

package/dist/components/Table/features/tableSort/components/SortButton/SortButton.styles.js

@@ -0,0 +1,20 @@
+const sortButtonStyle = (theme) => ({
+  display: "inline-flex",
+  flexDirection: "column",
+  rowGap: theme.x05,
+  paddingInline: 3.5,
+  paddingBlock: theme.paddingXS,
+  color: theme.textIcon
+});
+const getAscendArrowStyle = (sortOrder) => (theme) => ({
+  color: sortOrder === "ascend" ? theme.primaryBase : void 0
+});
+const getDescendArrowStyle = (sortOrder) => (theme) => ({
+  color: sortOrder === "descend" ? theme.primaryBase : void 0,
+  transform: "rotate(180deg)"
+});
+export {
+  getAscendArrowStyle,
+  getDescendArrowStyle,
+  sortButtonStyle
+};

package/dist/components/Table/features/tableSort/components/SortButton/SortButton.types.d.ts

@@ -0,0 +1,4 @@
+import { Columns } from 'components/Table/interfaces/tableColumns.types';
+export interface SortButtonProps<Record> {
+    column: Columns<Record>[number];
+}

package/dist/components/Table/features/tableSort/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { useTableSort } from './useTableSort/useTableSort';
+export type { SorterResult } from './useTableSort/useTableSort.types';
+export { useTransformColumns } from './useTransformColumns/useTransformColumns';
+export { useHeaderCellSort } from './useHeaderCellSort/useHeaderCellSort';
+export { useSortState } from './useSortState/useSortState';

package/dist/components/Table/features/tableSort/hooks/useHeaderCellSort/useHeaderCellSort.d.ts

@@ -0,0 +1,6 @@
+import { UseHeaderCellSortOptions } from './useHeaderCellSort.types';
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const useHeaderCellSort: <Record extends DefaultRecord>(options: UseHeaderCellSortOptions<Record>) => {
+    onClick: import('react').MouseEventHandler<HTMLTableCellElement>;
+    onKeyDown: import('react').KeyboardEventHandler<HTMLTableCellElement>;
+};

package/dist/components/Table/features/tableSort/hooks/useHeaderCellSort/useHeaderCellSort.js

@@ -0,0 +1,47 @@
+import { nextSortDirection } from "./useHeaderCellSort.utils.js";
+import { useSortState } from "../useSortState/useSortState.js";
+import { useTableStaticContext } from "../../../tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.js";
+import { getRefValue } from "../../../../utils/ref/ref.js";
+const useHeaderCellSort = (options) => {
+  const {
+    column,
+    onClick,
+    onKeyDown
+  } = options;
+  const staticContextRef = useTableStaticContext();
+  const columnKey = column.key;
+  const {
+    sortOrder,
+    sortDirections
+  } = useSortState({
+    column
+  });
+  const nextSortOrder = nextSortDirection(sortDirections, sortOrder);
+  const handleClick = (e) => {
+    const triggerSorter = getRefValue(staticContextRef, "triggerSorter");
+    triggerSorter({
+      column,
+      key: columnKey,
+      sortOrder: nextSortOrder
+    });
+    onClick == null ? void 0 : onClick(e);
+  };
+  const handleKeyDown = (e) => {
+    if (e.code === "Enter") {
+      const triggerSorter = getRefValue(staticContextRef, "triggerSorter");
+      triggerSorter({
+        column,
+        key: columnKey,
+        sortOrder: nextSortOrder
+      });
+    }
+    onKeyDown == null ? void 0 : onKeyDown(e);
+  };
+  return {
+    onClick: handleClick,
+    onKeyDown: handleKeyDown
+  };
+};
+export {
+  useHeaderCellSort
+};

package/dist/components/Table/features/tableSort/hooks/useHeaderCellSort/useHeaderCellSort.types.d.ts

@@ -0,0 +1,7 @@
+import { Column } from 'components/Table/interfaces/tableColumns.types';
+import { KeyboardEventHandler, MouseEventHandler } from 'react';
+export interface UseHeaderCellSortOptions<Record> {
+    column: Column<Record>;
+    onClick: MouseEventHandler<HTMLTableCellElement> | undefined;
+    onKeyDown: KeyboardEventHandler<HTMLTableCellElement> | undefined;
+}

package/dist/components/Table/features/tableSort/hooks/useHeaderCellSort/useHeaderCellSort.utils.d.ts

@@ -0,0 +1,2 @@
+import { SortOrder } from '../../types';
+export declare const nextSortDirection: (sortDirections: SortOrder[], current: SortOrder | null) => SortOrder;

package/dist/components/Table/features/tableSort/hooks/useHeaderCellSort/useHeaderCellSort.utils.js

@@ -0,0 +1,9 @@
+const nextSortDirection = (sortDirections, current) => {
+  if (!current) {
+    return sortDirections[0];
+  }
+  return sortDirections[sortDirections.indexOf(current) + 1];
+};
+export {
+  nextSortDirection
+};

package/dist/components/Table/features/tableSort/hooks/useSortState/useSortState.d.ts

@@ -0,0 +1,5 @@
+import { UseSortStateOptions } from './useSortState.types';
+export declare const useSortState: <Record>(options: UseSortStateOptions<Record>) => {
+    sortOrder: import('../..').SortOrder;
+    sortDirections: import('../..').SortOrder[];
+};

package/dist/components/Table/features/tableSort/hooks/useSortState/useSortState.js

@@ -0,0 +1,39 @@
+import { useState } from "react";
+import { useTableContext } from "../../../../contexts/tableContext/useTableContext/useTableContext.js";
+import { useTableStaticContext } from "../../../tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.js";
+import { getRefValue } from "../../../../utils/ref/ref.js";
+import { useSubscribe } from "../../../typedEventBus/hooks.js";
+const useSortState = (options) => {
+  const {
+    column
+  } = options;
+  const {
+    sortDirections: columnSortDirections,
+    key: columnKey
+  } = column;
+  const {
+    sortDirections: tableSortDirections
+  } = useTableContext();
+  const sortDirections = columnSortDirections || tableSortDirections;
+  const staticContextRef = useTableStaticContext();
+  const [sortOrder, setSortOrder] = useState(() => {
+    const sortState = getRefValue(staticContextRef, "sortState");
+    if (!sortState) {
+      return;
+    }
+    return sortState.key === columnKey ? sortState.sortOrder : void 0;
+  });
+  useSubscribe("sort", (value) => {
+    const {
+      sortState
+    } = value;
+    setSortOrder(sortState ? sortState.key === columnKey ? sortState.sortOrder : void 0 : void 0);
+  }, false, [columnKey]);
+  return {
+    sortOrder,
+    sortDirections
+  };
+};
+export {
+  useSortState
+};

package/dist/components/Table/features/tableSort/hooks/useSortState/useSortState.types.d.ts

@@ -0,0 +1,4 @@
+import { Columns } from 'components/Table/interfaces/tableColumns.types';
+export interface UseSortStateOptions<Record> {
+    column: Columns<Record>[number];
+}

package/dist/components/Table/features/tableSort/hooks/useTableSort/useTableSort.d.ts

@@ -0,0 +1,9 @@
+import { UseTableSortOptions } from './useTableSort.types';
+import { DefaultRecord } from 'components/Table/Table.types';
+import { SortState } from '../../types';
+export declare const useTableSort: <Record extends DefaultRecord>(options: UseTableSortOptions<Record>) => {
+    triggerSorter: (sortState: SortState<Record>) => void;
+    sortState: SortState<Record> | undefined;
+    sortedData: Record[];
+    hasData: boolean;
+};

package/dist/components/Table/features/tableSort/hooks/useTableSort/useTableSort.js

@@ -0,0 +1,54 @@
+import { useState, useMemo } from "react";
+import { useEvent } from "../../../../../../hooks/useEvent/useEvent.js";
+import { useTableStaticContext } from "../../../tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.js";
+import { getRefValue } from "../../../../utils/ref/ref.js";
+import { useEmitter } from "../../../typedEventBus/hooks.js";
+import { useFirstMountLayoutEffect } from "../../../../../../hooks/useFirstMountLayoutEffect/useFirstMountLayoutEffect.js";
+import { getSortedData } from "../../utils/getSortedData/getSortedData.js";
+const useTableSort = (options) => {
+  const {
+    onChange,
+    dataSource
+  } = options;
+  const staticContextRef = useTableStaticContext();
+  const [sortState, setSortState] = useState(() => getRefValue(staticContextRef, "initialSortState"));
+  const emitSort = useEvent(useEmitter("sort"));
+  useFirstMountLayoutEffect((firstMount) => {
+    if (firstMount) {
+      return;
+    }
+    emitSort({
+      sortState
+    });
+  }, [emitSort, sortState]);
+  const sortedData = useMemo(() => getSortedData(dataSource, sortState), [dataSource, sortState]);
+  const hasData = Boolean(sortedData.length);
+  const triggerSorter = (sortState2) => {
+    setSortState(sortState2);
+    const {
+      key,
+      column,
+      sortOrder
+    } = sortState2;
+    onChange == null ? void 0 : onChange(sortOrder ? {
+      columnKey: key,
+      column,
+      field: column.dataIndex,
+      order: sortOrder
+    } : {
+      columnKey: void 0,
+      column: void 0,
+      field: void 0,
+      order: void 0
+    });
+  };
+  return {
+    triggerSorter,
+    sortState,
+    sortedData,
+    hasData
+  };
+};
+export {
+  useTableSort
+};

package/dist/components/Table/features/tableSort/hooks/useTableSort/useTableSort.types.d.ts

@@ -0,0 +1,14 @@
+import { Column } from 'components/Table/interfaces/tableColumns.types';
+import { DefaultRecord, Key, TableProps } from 'components/Table/Table.types';
+import { SortOrder } from '../../types';
+import { PropertyPath } from 'lodash-es';
+export interface UseTableSortOptions<Record extends DefaultRecord> {
+    onChange: TableProps<Record>["onChange"];
+    dataSource: TableProps<Record>["dataSource"];
+}
+export interface SorterResult<Record> {
+    column?: Column<Record>;
+    order?: SortOrder;
+    field?: PropertyPath;
+    columnKey?: Key;
+}

package/dist/components/Table/features/tableSort/hooks/useTransformColumns/useTransformColumns.d.ts

@@ -0,0 +1,5 @@
+import { DefaultRecord } from 'components/Table/Table.types';
+import { ColumnsTransformer } from 'components/Table/interfaces/tableColumns.types';
+export declare const useTransformColumns: <Record extends DefaultRecord>() => {
+    transformColumns: ColumnsTransformer<Record>;
+};

package/dist/components/Table/features/tableSort/hooks/useTransformColumns/useTransformColumns.js

@@ -0,0 +1,47 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import { useCallback } from "react";
+import { SortButton } from "../../components/SortButton/SortButton.js";
+import { sorterTitleWrapperStyle } from "./useTransformColumns.styles.js";
+import { useTheme } from "../../../../../../hooks/useTheme/useTheme.js";
+import { useTableStaticContext } from "../../../tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.js";
+import { getRefValue, updateRefValue } from "../../../../utils/ref/ref.js";
+const useTransformColumns = () => {
+  const theme = useTheme();
+  const staticContextRef = useTableStaticContext();
+  const transformColumns = useCallback((columns) => {
+    function processColumns(columns2) {
+      return columns2.map((_column) => {
+        const column = {
+          ..._column
+        };
+        if (column.sorter) {
+          column.title = /* @__PURE__ */ jsxs("div", { css: sorterTitleWrapperStyle(theme), children: [
+            column.title,
+            /* @__PURE__ */ jsx(SortButton, { column })
+          ] });
+          const initialSortState = getRefValue(staticContextRef, "initialSortState");
+          if (!initialSortState && column.defaultSortOrder) {
+            updateRefValue(staticContextRef, {
+              initialSortState: {
+                column,
+                key: column.key,
+                sortOrder: column.defaultSortOrder
+              }
+            });
+          }
+        }
+        if ("children" in column) {
+          column.children = processColumns(column.children);
+        }
+        return column;
+      });
+    }
+    return processColumns(columns);
+  }, [staticContextRef, theme]);
+  return {
+    transformColumns
+  };
+};
+export {
+  useTransformColumns
+};

package/dist/components/Table/features/tableSort/hooks/useTransformColumns/useTransformColumns.styles.d.ts

@@ -0,0 +1,6 @@
+import { Theme } from 'themes';
+export declare const sorterTitleWrapperStyle: (theme: Theme) => {
+    display: string;
+    columnGap: 4;
+    alignItems: string;
+};

package/dist/components/Table/features/tableSort/hooks/useTransformColumns/useTransformColumns.styles.js

@@ -0,0 +1,8 @@
+const sorterTitleWrapperStyle = (theme) => ({
+  display: "flex",
+  columnGap: theme.spaceXS,
+  alignItems: "center"
+});
+export {
+  sorterTitleWrapperStyle
+};

package/dist/components/Table/features/tableSort/icons/ArrowFilled.d.ts

@@ -0,0 +1,2 @@
+import { IconComponentProps } from '@infomaximum/icons';
+export declare const ArrowFilled: import('react').ForwardRefExoticComponent<Omit<Partial<IconComponentProps>, "ref"> & import('react').RefAttributes<SVGSVGElement>>;

package/dist/components/Table/features/tableSort/icons/ArrowFilled.js

@@ -0,0 +1,12 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { Icon } from "@infomaximum/icons";
+import { forwardRef } from "react";
+const Arrow = (props) => {
+  return /* @__PURE__ */ jsx("svg", { ...props, width: "9", height: "5", viewBox: "0 0 9 5", children: /* @__PURE__ */ jsx("path", { d: "M7.9,5 H1.1 C0.7,5,0.5,4.5,0.8,4.2 l3.4,-3.8 c0.2,-0.2,0.5,-0.2,0.7,0 l3.4,3.8 C8.5,4.5,8.3,5,7.9,5 Z" }) });
+};
+const ArrowFilled = forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx(Icon, { component: Arrow, name: "arrow", ref, ...props });
+});
+export {
+  ArrowFilled
+};

package/dist/components/Table/features/tableSort/icons/index.d.ts

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

package/dist/components/Table/features/tableSort/index.d.ts

@@ -0,0 +1,5 @@
+export { defaultSortDirections, defaultRowSelectionColumnWidth, defaultIndentSize, getSortFunction, } from './utils';
+export { useTableSort, useTransformColumns, type SorterResult, useHeaderCellSort, useSortState, } from './hooks';
+export type { SortState, SortOrder, CompareFn } from './types';
+export { ArrowFilled } from './icons';
+export { HeaderCellWithSort } from './components/HeaderCellWithSort/HeaderCellWithSort';

package/dist/components/Table/features/tableSort/types.d.ts

@@ -0,0 +1,10 @@
+import { Column } from 'components/Table/interfaces/tableColumns.types';
+import { Key } from 'components/Table/Table.types';
+export type SortOrder = "descend" | "ascend" | undefined;
+export type CompareFn<Record> = (a: Record, b: Record, sortOrder?: SortOrder) => number;
+export type Sorter<Record> = boolean | CompareFn<Record>;
+export interface SortState<Record> {
+    column: Column<Record>;
+    key: Key;
+    sortOrder: SortOrder;
+}

package/dist/components/Table/features/tableSort/utils/const.d.ts

@@ -0,0 +1,4 @@
+import { SortOrder } from '../types';
+export declare const defaultSortDirections: SortOrder[];
+export declare const defaultRowSelectionColumnWidth = 36;
+export declare const defaultIndentSize = 16;

package/dist/components/Table/features/tableSort/utils/const.js

@@ -0,0 +1,8 @@
+const defaultSortDirections = ["ascend", "descend"];
+const defaultRowSelectionColumnWidth = 36;
+const defaultIndentSize = 16;
+export {
+  defaultIndentSize,
+  defaultRowSelectionColumnWidth,
+  defaultSortDirections
+};

package/dist/components/Table/features/tableSort/utils/getSortFunction/getSortFunction.d.ts

@@ -0,0 +1,2 @@
+import { Sorter } from '../../types';
+export declare const getSortFunction: <Record>(sorter?: Sorter<Record>) => false | import('../..').CompareFn<Record>;

package/dist/components/Table/features/tableSort/utils/getSortFunction/getSortFunction.js

@@ -0,0 +1,9 @@
+const getSortFunction = (sorter) => {
+  if (typeof sorter === "function") {
+    return sorter;
+  }
+  return false;
+};
+export {
+  getSortFunction
+};

package/dist/components/Table/features/tableSort/utils/getSortFunction/index.d.ts

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

package/dist/components/Table/features/tableSort/utils/getSortedData/getSortedData.d.ts

@@ -0,0 +1,3 @@
+import { DefaultRecord } from 'components/Table/Table.types';
+import { SortState } from '../../types';
+export declare const getSortedData: <Record extends DefaultRecord<Record>>(data: readonly Record[], sortState: SortState<Record> | undefined) => Record[];

package/dist/components/Table/features/tableSort/utils/getSortedData/getSortedData.js

@@ -0,0 +1,48 @@
+import { getSortFunction } from "../getSortFunction/getSortFunction.js";
+const getSortedData = (data, sortState) => {
+  const innerSorterStates = sortState ? [sortState] : [];
+  const cloneData = data.slice();
+  const runningSorters = innerSorterStates.filter(({
+    column: {
+      sorter
+    },
+    sortOrder
+  }) => {
+    const sortFn = getSortFunction(sorter);
+    return sortFn && sortOrder;
+  });
+  if (!runningSorters.length) {
+    return cloneData;
+  }
+  return cloneData.sort((record1, record2) => {
+    for (let i = 0; i < runningSorters.length; i += 1) {
+      const sorterState = runningSorters[i];
+      const {
+        column: {
+          sorter
+        },
+        sortOrder
+      } = sorterState;
+      const compareFn = getSortFunction(sorter);
+      if (compareFn && sortOrder) {
+        const compareResult = compareFn(record1, record2, sortOrder);
+        if (compareResult !== 0) {
+          return sortOrder === "ascend" ? compareResult : -compareResult;
+        }
+      }
+    }
+    return 0;
+  }).map((record) => {
+    const subRecords = record.children;
+    if (subRecords) {
+      return {
+        ...record,
+        children: getSortedData(subRecords, sortState)
+      };
+    }
+    return record;
+  });
+};
+export {
+  getSortedData
+};

package/dist/components/Table/features/tableSort/utils/getSortedData/index.d.ts

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

package/dist/components/Table/features/tableSort/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { defaultSortDirections, defaultRowSelectionColumnWidth, defaultIndentSize } from './const';
+export { getSortFunction } from './getSortFunction';

package/dist/components/Table/features/tableStaticContext/contexts/index.d.ts

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

package/dist/components/Table/features/tableStaticContext/contexts/tableStaticContext/TableStaticContext.d.ts

@@ -0,0 +1,21 @@
+import { TableStaticContextValue } from './TableStaticContext.types';
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const initialTableStaticContextValue: {
+    readonly staticSelectedKeySet: Set<import('react').Key>;
+    readonly triggerSorter: (...args: any[]) => void;
+    readonly sortState: undefined;
+    readonly colsWidthsMap: Map<any, any>;
+    readonly isTableFirstMount: true;
+    readonly measureCellsInfo: {
+        readonly start: readonly [];
+        readonly end: readonly [];
+        readonly widths: readonly [];
+    };
+    readonly scrollableTableSectionInfo: {
+        readonly clientWidth: 0;
+        readonly horizontalScrollPositionRange: readonly [0, 0];
+        readonly verticalScrollBarWidth: 0;
+    };
+    readonly initialSortState: undefined;
+};
+export declare const createTableStaticContext: <Record extends DefaultRecord>() => import('react').Context<TableStaticContextValue<Record>>;

package/dist/components/Table/features/tableStaticContext/contexts/tableStaticContext/TableStaticContext.js

@@ -0,0 +1,29 @@
+import { createContext } from "react";
+import { noop, once } from "lodash-es";
+const initialTableStaticContextValue = {
+  staticSelectedKeySet: /* @__PURE__ */ new Set(),
+  triggerSorter: noop,
+  sortState: void 0,
+  colsWidthsMap: /* @__PURE__ */ new Map(),
+  isTableFirstMount: true,
+  measureCellsInfo: {
+    start: [],
+    end: [],
+    widths: []
+  },
+  scrollableTableSectionInfo: {
+    clientWidth: 0,
+    horizontalScrollPositionRange: [0, 0],
+    verticalScrollBarWidth: 0
+  },
+  initialSortState: void 0
+};
+const createTableStaticContext = once(() => {
+  return createContext({
+    current: initialTableStaticContextValue
+  });
+});
+export {
+  createTableStaticContext,
+  initialTableStaticContextValue
+};

package/dist/components/Table/features/tableStaticContext/contexts/tableStaticContext/TableStaticContext.types.d.ts

@@ -0,0 +1,24 @@
+import { MutableRefObject } from 'react';
+import { DefaultRecord, Key } from 'components/Table/Table.types';
+import { ColumnKey, OffsetWidth } from 'components/Table/components/Body/components/MeasureRow/MeasureRow';
+import { SortState } from 'components/Table/features/tableSort';
+export type TableStaticValue<Record extends DefaultRecord> = {
+    staticSelectedKeySet: Set<Key>;
+    scrollableTableSectionInfo: {
+        horizontalScrollPositionRange: readonly [number, number];
+        verticalScrollBarWidth: number;
+        clientWidth: number;
+    };
+    measureCellsInfo: {
+        start: readonly number[];
+        end: readonly number[];
+        widths: readonly number[];
+    };
+    colsWidthsMap: Map<ColumnKey, OffsetWidth>;
+    isTableFirstMount: boolean;
+    initialSortState: SortState<Record> | undefined;
+    sortState: SortState<Record> | undefined;
+    triggerSorter: (sortState: SortState<Record>) => void;
+};
+export interface TableStaticContextValue<Record extends DefaultRecord> extends MutableRefObject<TableStaticValue<Record>> {
+}

package/dist/components/Table/features/tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const useTableStaticContext: <Record extends DefaultRecord>() => import('../TableStaticContext.types').TableStaticContextValue<Record>;

package/dist/components/Table/features/tableStaticContext/contexts/tableStaticContext/useTableStaticContext/useTableStaticContext.js

@@ -0,0 +1,8 @@
+import { useContext } from "react";
+import { createTableStaticContext } from "../TableStaticContext.js";
+const useTableStaticContext = () => {
+  return useContext(createTableStaticContext());
+};
+export {
+  useTableStaticContext
+};

package/dist/components/Table/features/tableStaticContext/hocs/index.d.ts

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

package/dist/components/Table/features/tableStaticContext/hocs/withTableStaticContext.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { DefaultRecord } from 'components/Table/Table.types';
+export declare const withTableStaticContext: <T extends FC<any>, Record extends DefaultRecord>(Component: T) => import('react').ForwardRefExoticComponent<Omit<any, "ref"> & import('react').RefAttributes<unknown>>;

package/dist/components/Table/features/tableStaticContext/hocs/withTableStaticContext.js

@@ -0,0 +1,15 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { forwardRef, useRef } from "react";
+import { useStatic } from "../../../../../hooks/useStatic/useStatic.js";
+import { initialTableStaticContextValue, createTableStaticContext } from "../contexts/tableStaticContext/TableStaticContext.js";
+const withTableStaticContext = (Component) => {
+  const WithTableStaticContext = forwardRef((props, ref) => {
+    const TableStaticContext = useStatic(() => createTableStaticContext());
+    const tableStaticContextValueRef = useRef(initialTableStaticContextValue);
+    return /* @__PURE__ */ jsx(TableStaticContext.Provider, { value: tableStaticContextValueRef, children: /* @__PURE__ */ jsx(Component, { ref, ...props }) });
+  });
+  return WithTableStaticContext;
+};
+export {
+  withTableStaticContext
+};

package/dist/components/Table/features/tableStaticContext/index.d.ts

@@ -0,0 +1,2 @@
+export { withTableStaticContext } from './hocs';
+export { useTableStaticContext } from './contexts';