@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/es/space/constants.d.ts

@@ -0,0 +1,10 @@
+declare const cssClasses: {
+    PREFIX: string;
+};
+declare const strings: {
+    ALIGN_SET: string[];
+    SPACING_LOOSE: string;
+    SPACING_MEDIUM: string;
+    SPACING_TIGHT: string;
+};
+export { cssClasses, strings };

package/lib/es/space/constants.js

@@ -0,0 +1,11 @@
+import { BASE_CLASS_PREFIX } from '../base/constants';
+const cssClasses = {
+  PREFIX: `${BASE_CLASS_PREFIX}-space`
+};
+const strings = {
+  ALIGN_SET: ['start', 'end', 'center', 'baseline'],
+  SPACING_LOOSE: 'loose',
+  SPACING_MEDIUM: 'medium',
+  SPACING_TIGHT: 'tight'
+};
+export { cssClasses, strings };

package/lib/es/spin/constants.d.ts

@@ -0,0 +1,8 @@
+declare const cssClasses: {
+    PREFIX: string;
+};
+declare const strings: {
+    SIZE: string[];
+};
+declare const numbers: {};
+export { cssClasses, strings, numbers };

package/lib/es/spin/constants.js

@@ -0,0 +1,10 @@
+import { BASE_CLASS_PREFIX } from '../base/constants';
+const PREFIX = `${BASE_CLASS_PREFIX}-spin`;
+const cssClasses = {
+  PREFIX
+};
+const strings = {
+  SIZE: ['small', 'middle', 'large']
+};
+const numbers = {};
+export { cssClasses, strings, numbers };

package/lib/es/spin/foundation.d.ts

@@ -0,0 +1,12 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface SpinAdapter extends Partial<DefaultAdapter> {
+    setLoading: (val: boolean) => void;
+}
+declare class SpinFoundation extends BaseFoundation<SpinAdapter> {
+    _timer: ReturnType<typeof setTimeout>;
+    static get spinDefaultAdapter(): SpinAdapter;
+    constructor(adapter: SpinAdapter);
+    updateLoadingIfNeedDelay(): void;
+    destroy(): void;
+}
+export default SpinFoundation;

package/lib/es/spin/foundation.js

@@ -0,0 +1,45 @@
+import BaseFoundation from '../base/foundation';
+
+class SpinFoundation extends BaseFoundation {
+  constructor(adapter) {
+    super(Object.assign(Object.assign({}, SpinFoundation.spinDefaultAdapter), adapter));
+  }
+
+  static get spinDefaultAdapter() {
+    return {
+      getProp: () => undefined,
+      setLoading: val => undefined
+    };
+  }
+
+  updateLoadingIfNeedDelay() {
+    const {
+      spinning: propsSpinning,
+      delay: propsDelay
+    } = this._adapter.getProps();
+
+    const {
+      delay
+    } = this._adapter.getStates();
+
+    if (delay) {
+      const self = this;
+      this._timer = setTimeout(() => {
+        self._adapter.setState({
+          loading: propsSpinning,
+          delay: 0
+        });
+      }, propsDelay);
+    }
+  }
+
+  destroy() {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+    }
+  }
+
+}
+
+export default SpinFoundation;

package/lib/es/steps/constants.d.ts

@@ -0,0 +1,5 @@
+declare const stepsClasses: {
+    PREFIX: string;
+    ITEM: string;
+};
+export { stepsClasses };

package/lib/es/steps/constants.js

@@ -0,0 +1,6 @@
+import { BASE_CLASS_PREFIX } from '../base/constants';
+const stepsClasses = {
+  PREFIX: `${BASE_CLASS_PREFIX}-steps`,
+  ITEM: `${BASE_CLASS_PREFIX}-steps-item`
+};
+export { stepsClasses };

package/lib/es/switch/constants.d.ts

@@ -0,0 +1,19 @@
+declare const cssClasses: {
+    PREFIX: string;
+    FOCUS: string;
+    LARGE: string;
+    SMALL: string;
+    CHECKED: string;
+    DISABLED: string;
+    ACTIVE: string;
+    KNOB: string;
+    NATIVE_CONTROL: string;
+    CHECKED_TEXT: string;
+    UNCHECKED_TEXT: string;
+    LOADING_SPIN: string;
+    LOADING: string;
+};
+declare const strings: {
+    readonly SIZE_MAP: readonly ["default", "small", "large"];
+};
+export { cssClasses, strings };

package/lib/es/switch/constants.js

@@ -0,0 +1,20 @@
+import { BASE_CLASS_PREFIX } from '../base/constants';
+const cssClasses = {
+  PREFIX: `${BASE_CLASS_PREFIX}-switch`,
+  FOCUS: `${BASE_CLASS_PREFIX}-switch-focus`,
+  LARGE: `${BASE_CLASS_PREFIX}-switch-large`,
+  SMALL: `${BASE_CLASS_PREFIX}-switch-small`,
+  CHECKED: `${BASE_CLASS_PREFIX}-switch-checked`,
+  DISABLED: `${BASE_CLASS_PREFIX}-switch-disabled`,
+  ACTIVE: `${BASE_CLASS_PREFIX}-switch-active`,
+  KNOB: `${BASE_CLASS_PREFIX}-switch-knob`,
+  NATIVE_CONTROL: `${BASE_CLASS_PREFIX}-switch-native-control`,
+  CHECKED_TEXT: `${BASE_CLASS_PREFIX}-switch-checked-text`,
+  UNCHECKED_TEXT: `${BASE_CLASS_PREFIX}-switch-unchecked-text`,
+  LOADING_SPIN: `${BASE_CLASS_PREFIX}-switch-loading-spin`,
+  LOADING: `${BASE_CLASS_PREFIX}-switch-loading`
+};
+const strings = {
+  SIZE_MAP: ['default', 'small', 'large']
+};
+export { cssClasses, strings };

package/lib/es/switch/foundation.d.ts

@@ -0,0 +1,17 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface SwitchAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    setNativeControlChecked: (nativeControlChecked: boolean | undefined) => void;
+    setNativeControlDisabled: (nativeControlDisabled: boolean | undefined) => void;
+    setFocusVisible: (focusVisible: boolean) => void;
+    notifyChange: (checked: boolean, e: any) => void;
+}
+export default class SwitchFoundation<P = Record<string, any>, S = Record<string, any>> extends BaseFoundation<SwitchAdapter<P, S>, P, S> {
+    constructor(adapter: SwitchAdapter<P, S>);
+    init(): void;
+    setChecked(checked: boolean | undefined): void;
+    setDisabled(disabled: boolean | undefined): void;
+    handleChange(checked: boolean, e: any): void;
+    handleFocusVisible: (event: any) => void;
+    handleBlur: () => void;
+    destroy(): void;
+}

package/lib/es/switch/foundation.js

@@ -0,0 +1,60 @@
+import BaseFoundation from '../base/foundation';
+import warning from '../utils/warning';
+export default class SwitchFoundation extends BaseFoundation {
+  constructor(adapter) {
+    super(Object.assign({}, adapter));
+
+    this.handleFocusVisible = event => {
+      const {
+        target
+      } = event;
+
+      try {
+        if (target.matches(':focus-visible')) {
+          this._adapter.setFocusVisible(true);
+        }
+      } catch (error) {
+        warning(true, 'Warning: [Semi Switch] The current browser does not support the focus-visible');
+      }
+    };
+
+    this.handleBlur = () => {
+      this._adapter.setFocusVisible(false);
+    };
+  }
+
+  init() {
+    const {
+      defaultChecked,
+      checked,
+      disabled
+    } = this.getProps();
+    this.setChecked(defaultChecked || checked);
+    this.setDisabled(disabled);
+  }
+
+  setChecked(checked) {
+    this._adapter.setNativeControlChecked(checked);
+  }
+
+  setDisabled(disabled) {
+    this._adapter.setNativeControlDisabled(disabled);
+  }
+
+  handleChange(checked, e) {
+    const propChecked = this.getProps().checked;
+    const isControlledComponent = typeof propChecked !== 'undefined';
+
+    if (isControlledComponent) {
+      this._adapter.notifyChange(checked, e);
+    } else {
+      this._adapter.setNativeControlChecked(checked);
+
+      this._adapter.notifyChange(checked, e);
+    }
+  } // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+
+  destroy() {}
+
+}

package/lib/es/table/bodyFoundation.d.ts

@@ -0,0 +1,38 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface BodyAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    setVirtualizedData: (virtualizedData: any[], cb: () => void) => void;
+    setCachedExpandBtnShouldInRow: (cachedExpandBtnShouldInRow: boolean) => void;
+    setCachedExpandRelatedProps: (cachedExpandRelatedProps: string[]) => void;
+    observeBodyResize: (bodyWrapDOM: any) => void;
+    unobserveBodyResize: () => void;
+}
+export default class TableBodyFoundation<P = Record<string, any>, S = Record<string, any>> extends BaseFoundation<BodyAdapter<P, S>, P, S> {
+    init(): void;
+    destroy(): void;
+    initVirtualizedData(cb?: (...args: any[]) => void): void;
+    initExpandBtnShouldInRow(newExpandRelatedProps?: any[]): void;
+    flattenData(dataSource?: any[], level?: number, parentKeys?: any[], childrenKeys?: any[]): (FlattenData | GroupFlattenData)[];
+    /**
+     * Use ResizeObserver to monitor changes in the size of the body content area, and notify Table to recalculate if it changes. columns #1219
+     * (Only monitor the scroll.y scene, other scenes are not monitored, because the header of the scroll.y scene is a separate table, and a scrollbar column will be inserted)
+     */
+    observeBodyResize(bodyDOM: any): void;
+    unobserveBodyResize(): void;
+}
+export interface GroupFlattenData {
+    key: number | string;
+    level: number;
+    sectionRow: boolean;
+    group: Map<string, Record<string, any>[]>;
+    groupKey: number;
+    expanded: boolean;
+}
+export interface FlattenData {
+    key: number | string;
+    record: Record<string, any>;
+    level: number;
+    parentKeys?: any[];
+    childrenKeys?: any[];
+    expandedRow?: boolean;
+    sectionRow?: boolean;
+}

package/lib/es/table/bodyFoundation.js

@@ -0,0 +1,134 @@
+import _isObject from "lodash/isObject";
+import _findLastIndex from "lodash/findLastIndex";
+import _isMap from "lodash/isMap";
+import _includes from "lodash/includes";
+import _get from "lodash/get";
+import BaseFoundation from '../base/foundation';
+import { strings } from './constants';
+import { getRecordKey, genExpandedRowKey, getRecordChildren, expandBtnShouldInRow } from './utils';
+export default class TableBodyFoundation extends BaseFoundation {
+  init() {
+    this.initVirtualizedData();
+    this.initExpandBtnShouldInRow();
+  }
+
+  destroy() {
+    this.unobserveBodyResize();
+  }
+
+  initVirtualizedData(cb) {
+    this._adapter.setVirtualizedData(this.flattenData(this.getProp('dataSource')), cb);
+  }
+
+  initExpandBtnShouldInRow(newExpandRelatedProps) {
+    const props = this.getProps(); // TODO check: this._adapter.getProps -> this.getProps
+
+    const cachedExpandBtnShouldInRow = expandBtnShouldInRow(props);
+
+    this._adapter.setCachedExpandBtnShouldInRow(cachedExpandBtnShouldInRow);
+
+    if (!_isObject(newExpandRelatedProps) && !newExpandRelatedProps) {
+      const expandRelatedProps = strings.EXPAND_RELATED_PROPS; // eslint-disable-next-line no-param-reassign
+
+      newExpandRelatedProps = expandRelatedProps.map(key => _get(props, key, undefined));
+    }
+
+    this._adapter.setCachedExpandRelatedProps(newExpandRelatedProps);
+  }
+
+  flattenData() {
+    let dataSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    let level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let parentKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    let childrenKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+    const flattenData = [];
+    const {
+      rowKey,
+      childrenRecordName,
+      expandedRowRender,
+      expandedRowKeys,
+      groups
+    } = this.getProps();
+
+    if (level === 0 && _isMap(groups)) {
+      groups.forEach((set, key) => {
+        const firstIndex = dataSource.findIndex(record => set.has(getRecordKey(record, rowKey)));
+
+        if (firstIndex > -1) {
+          const lastIndex = _findLastIndex(dataSource, record => set.has(getRecordKey(record, rowKey)));
+
+          const expanded = _includes(expandedRowKeys, key);
+
+          flattenData.push({
+            key,
+            level,
+            sectionRow: true,
+            group: set,
+            groupKey: key,
+            expanded
+          });
+
+          if (expanded) {
+            flattenData.push(...this.flattenData(dataSource.slice(firstIndex, lastIndex + 1), level + 1, [...parentKeys], [...childrenKeys]));
+          }
+        }
+      });
+    } else {
+      dataSource.forEach((record, index) => {
+        const recordKey = getRecordKey(record, rowKey);
+        const children = getRecordChildren(record, childrenRecordName);
+
+        if (level) {
+          childrenKeys.push(recordKey);
+        }
+
+        const item = {
+          key: recordKey,
+          record,
+          level,
+          parentKeys: [...parentKeys],
+          childrenKeys: [...childrenKeys]
+        };
+        flattenData.push(item);
+        const extras = [];
+
+        if (_includes(expandedRowKeys, recordKey)) {
+          if (Array.isArray(children) && children.length) {
+            extras.push(...this.flattenData(children, level + 1, [...item.parentKeys], [...item.childrenKeys]));
+          } else if (expandedRowRender) {
+            extras.push({
+              key: genExpandedRowKey(recordKey),
+              level,
+              expandedRow: true,
+              record
+            });
+          }
+
+          flattenData.push(...extras);
+        }
+      });
+    }
+
+    return flattenData;
+  }
+  /**
+   * Use ResizeObserver to monitor changes in the size of the body content area, and notify Table to recalculate if it changes. columns #1219
+   * (Only monitor the scroll.y scene, other scenes are not monitored, because the header of the scroll.y scene is a separate table, and a scrollbar column will be inserted)
+   */
+
+
+  observeBodyResize(bodyDOM) {
+    const {
+      scroll
+    } = this.getProps(); // TODO check: this._adapter.getProps -> this.getProps
+
+    if (_get(scroll, 'y')) {
+      return this._adapter.observeBodyResize(bodyDOM);
+    }
+  }
+
+  unobserveBodyResize() {
+    return this._adapter.unobserveBodyResize();
+  }
+
+}

package/lib/es/table/cellFoundation.d.ts

@@ -0,0 +1,7 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface TableCellAdapter extends DefaultAdapter {
+    notifyClick: (record: Record<string, any>, e: any) => void;
+}
+export default class TableCellFoundation extends BaseFoundation<TableCellAdapter> {
+    handleClick(e: any): void;
+}

package/lib/es/table/cellFoundation.js

@@ -0,0 +1,7 @@
+import BaseFoundation from '../base/foundation';
+export default class TableCellFoundation extends BaseFoundation {
+  handleClick(e) {
+    this._adapter.notifyClick(this.getProp('record'), e);
+  }
+
+}

package/lib/es/table/constants.d.ts

@@ -0,0 +1,77 @@
+declare const cssClasses: {
+    readonly PREFIX: "semi-table";
+    readonly TABLE: "semi-table";
+    readonly WRAP: "semi-table-wrapper";
+    readonly THEAD: "semi-table-thead";
+    readonly TR: "semi-table-row";
+    readonly TH: "semi-table-row-head";
+    readonly TD: "semi-table-row-cell";
+};
+declare const strings: {
+    readonly SIZE_SMALL: "small";
+    readonly SIZE_MIDDLE: "middle";
+    readonly SIZES: readonly ["small", "default", "middle"];
+    readonly LAYOUTS: readonly ["", "auto", "fixed"];
+    readonly PAGINATION_POSITIONS: readonly ["bottom", "top", "both"];
+    readonly FOOTER_POSITIONS: readonly [false, true, "left", "right"];
+    readonly SORT_DIRECTIONS: readonly ["ascend", "descend"];
+    readonly FIXED_SET: readonly [false, true, "left", "right"];
+    readonly ALIGNS: readonly ["left", "right", "center"];
+    readonly SCROLL_HORIZONTAL_POSITIONS: readonly ["left", "middle", "right"];
+    readonly DEFAULT_KEY_COLUMN_SELECTION: "column-selection";
+    readonly DEFAULT_KEY_COLUMN_EXPAND: "column-expand";
+    readonly DEFAULT_KEY_COLUMN_TITLE: "column-title";
+    readonly DEFAULT_KEY_COLUMN_SORTER: "column-sorter";
+    readonly DEFAULT_KEY_COLUMN_FILTER: "column-filter";
+    readonly DEFAULT_KEY_COLUMN_SCROLLBAR: "column-scrollbar";
+    readonly DEFAULT_COMPONENTS: {
+        readonly table: "table";
+        readonly header: {
+            readonly outer: "table";
+            readonly wrapper: "thead";
+            readonly row: "tr";
+            readonly cell: "th";
+        };
+        readonly body: {
+            readonly outer: "table";
+            readonly wrapper: "tbody";
+            readonly row: "tr";
+            readonly cell: "td";
+        };
+        readonly footer: {
+            readonly wrapper: "tfoot";
+            readonly row: "tr";
+            readonly cell: "td";
+        };
+    };
+    readonly EXPAND_RELATED_PROPS: readonly ["expandedRowRender", "dataSource", "hideExpandedColumn", "childrenRecordName", "rowExpandable"];
+};
+declare const numbers: {
+    readonly DEFAULT_PAGE_SIZE: 10;
+    readonly DEFAULT_WIDTH_COLUMN_EXPAND: 60;
+    readonly DEFAULT_WIDTH_COLUMN_SELECTION: 60;
+    readonly DEFAULT_INDENT_WIDTH: 20;
+    readonly DEFAULT_CELL_PADDING_LEFT: 16;
+    readonly DEFAULT_CELL_PADDING_RIGHT: 16;
+    readonly DEFAULT_CELL_PADDING_TOP: 16;
+    readonly DEFAULT_CELL_PADDING_BOTTOM: 16;
+    readonly DEFAULT_CELL_MIDDLE_PADDING_TOP: 12;
+    readonly DEFAULT_CELL_MIDDLE_PADDING_BOTTOM: 12;
+    readonly DEFAULT_CELL_SMALL_PADDING_TOP: 8;
+    readonly DEFAULT_CELL_SMALL_PADDING_BOTTOM: 8;
+    readonly DEFAULT_CELL_BORDER_WIDTH_LEFT: 1;
+    readonly DEFAULT_CELL_BORDER_WIDTH_RIGHT: 1;
+    readonly DEFAULT_CELL_BORDER_WITH_BOTTOM: 1;
+    readonly DEFAULT_CELL_LINE_HEIGHT: 20;
+    readonly DEFAULT_VIRTUALIZED_BODY_HEIGHT: 600;
+    readonly DEFAULT_VIRTUALIZED_SECTION_ROW_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_ROW_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_ROW_MIN_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_SECTION_ROW_MIDDLE_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_ROW_MIDDLE_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_ROW_MIDDLE_MIN_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_SECTION_ROW_SMALL_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_ROW_SMALL_HEIGHT: number;
+    readonly DEFAULT_VIRTUALIZED_ROW_SMALL_MIN_HEIGHT: number;
+};
+export { cssClasses, strings, numbers };

package/lib/es/table/constants.js

@@ -0,0 +1,97 @@
+/* eslint-disable max-len */
+import { BASE_CLASS_PREFIX } from '../base/constants';
+const cssClasses = {
+  PREFIX: `${BASE_CLASS_PREFIX}-table`,
+  TABLE: `${BASE_CLASS_PREFIX}-table`,
+  WRAP: `${BASE_CLASS_PREFIX}-table-wrapper`,
+  THEAD: `${BASE_CLASS_PREFIX}-table-thead`,
+  TR: `${BASE_CLASS_PREFIX}-table-row`,
+  TH: `${BASE_CLASS_PREFIX}-table-row-head`,
+  TD: `${BASE_CLASS_PREFIX}-table-row-cell`
+};
+const strings = {
+  SIZE_SMALL: 'small',
+  SIZE_MIDDLE: 'middle',
+  SIZES: ['small', 'default', 'middle'],
+  LAYOUTS: ['', 'auto', 'fixed'],
+  PAGINATION_POSITIONS: ['bottom', 'top', 'both'],
+  FOOTER_POSITIONS: [false, true, 'left', 'right'],
+  SORT_DIRECTIONS: ['ascend', 'descend'],
+  FIXED_SET: [false, true, 'left', 'right'],
+  ALIGNS: ['left', 'right', 'center'],
+  SCROLL_HORIZONTAL_POSITIONS: ['left', 'middle', 'right'],
+  DEFAULT_KEY_COLUMN_SELECTION: 'column-selection',
+  DEFAULT_KEY_COLUMN_EXPAND: 'column-expand',
+  DEFAULT_KEY_COLUMN_TITLE: 'column-title',
+  DEFAULT_KEY_COLUMN_SORTER: 'column-sorter',
+  DEFAULT_KEY_COLUMN_FILTER: 'column-filter',
+  DEFAULT_KEY_COLUMN_SCROLLBAR: 'column-scrollbar',
+  DEFAULT_COMPONENTS: {
+    table: 'table',
+    header: {
+      outer: 'table',
+      wrapper: 'thead',
+      row: 'tr',
+      cell: 'th'
+    },
+    body: {
+      outer: 'table',
+      wrapper: 'tbody',
+      row: 'tr',
+      cell: 'td'
+    },
+    footer: {
+      wrapper: 'tfoot',
+      row: 'tr',
+      cell: 'td'
+    }
+  },
+  EXPAND_RELATED_PROPS: ['expandedRowRender', 'dataSource', 'hideExpandedColumn', 'childrenRecordName', 'rowExpandable']
+};
+const DEFAULT_CELL_BORDER_WITH_BOTTOM = 1;
+const DEFAULT_CELL_BORDER_WITH_TOP = 0;
+const DEFAULT_CELL_PADDING_TOP = 16;
+const DEFAULT_CELL_PADDING_BOTTOM = 16;
+const DEFAULT_CELL_MIDDLE_PADDING_TOP = 12;
+const DEFAULT_CELL_MIDDLE_PADDING_BOTTOM = 12;
+const DEFAULT_CELL_SMALL_PADDING_TOP = 8;
+const DEFAULT_CELL_SMALL_PADDING_BOTTOM = 8;
+const DEFAULT_CELL_LINE_HEIGHT = 20; // normal size
+
+const DEFAULT_VIRTUALIZED_ROW_HEIGHT = DEFAULT_CELL_LINE_HEIGHT + DEFAULT_CELL_BORDER_WITH_BOTTOM + DEFAULT_CELL_BORDER_WITH_TOP + DEFAULT_CELL_PADDING_TOP + DEFAULT_CELL_PADDING_BOTTOM;
+const DEFAULT_VIRTUALIZED_ROW_MIN_HEIGHT = DEFAULT_CELL_PADDING_TOP + DEFAULT_CELL_PADDING_BOTTOM + DEFAULT_CELL_BORDER_WITH_BOTTOM; // middle  size
+
+const DEFAULT_VIRTUALIZED_ROW_MIDDLE_HEIGHT = DEFAULT_CELL_LINE_HEIGHT + DEFAULT_CELL_BORDER_WITH_BOTTOM + DEFAULT_CELL_BORDER_WITH_TOP + DEFAULT_CELL_MIDDLE_PADDING_TOP + DEFAULT_CELL_MIDDLE_PADDING_BOTTOM;
+const DEFAULT_VIRTUALIZED_ROW_MIDDLE_MIN_HEIGHT = DEFAULT_CELL_MIDDLE_PADDING_TOP + DEFAULT_CELL_MIDDLE_PADDING_BOTTOM + DEFAULT_CELL_BORDER_WITH_BOTTOM; // small size
+
+const DEFAULT_VIRTUALIZED_ROW_SMALL_HEIGHT = DEFAULT_CELL_LINE_HEIGHT + DEFAULT_CELL_BORDER_WITH_BOTTOM + DEFAULT_CELL_BORDER_WITH_TOP + DEFAULT_CELL_SMALL_PADDING_BOTTOM + DEFAULT_CELL_SMALL_PADDING_TOP;
+const DEFAULT_VIRTUALIZED_ROW_SMALL_MIN_HEIGHT = DEFAULT_CELL_SMALL_PADDING_TOP + DEFAULT_CELL_SMALL_PADDING_BOTTOM + DEFAULT_CELL_BORDER_WITH_BOTTOM;
+const numbers = {
+  DEFAULT_PAGE_SIZE: 10,
+  DEFAULT_WIDTH_COLUMN_EXPAND: 60,
+  DEFAULT_WIDTH_COLUMN_SELECTION: 60,
+  DEFAULT_INDENT_WIDTH: 20,
+  DEFAULT_CELL_PADDING_LEFT: 16,
+  DEFAULT_CELL_PADDING_RIGHT: 16,
+  DEFAULT_CELL_PADDING_TOP,
+  DEFAULT_CELL_PADDING_BOTTOM,
+  DEFAULT_CELL_MIDDLE_PADDING_TOP,
+  DEFAULT_CELL_MIDDLE_PADDING_BOTTOM,
+  DEFAULT_CELL_SMALL_PADDING_TOP,
+  DEFAULT_CELL_SMALL_PADDING_BOTTOM,
+  DEFAULT_CELL_BORDER_WIDTH_LEFT: 1,
+  DEFAULT_CELL_BORDER_WIDTH_RIGHT: 1,
+  DEFAULT_CELL_BORDER_WITH_BOTTOM,
+  DEFAULT_CELL_LINE_HEIGHT,
+  DEFAULT_VIRTUALIZED_BODY_HEIGHT: 600,
+  DEFAULT_VIRTUALIZED_SECTION_ROW_HEIGHT: DEFAULT_VIRTUALIZED_ROW_HEIGHT,
+  DEFAULT_VIRTUALIZED_ROW_HEIGHT,
+  DEFAULT_VIRTUALIZED_ROW_MIN_HEIGHT,
+  DEFAULT_VIRTUALIZED_SECTION_ROW_MIDDLE_HEIGHT: DEFAULT_VIRTUALIZED_ROW_MIDDLE_HEIGHT,
+  DEFAULT_VIRTUALIZED_ROW_MIDDLE_HEIGHT,
+  DEFAULT_VIRTUALIZED_ROW_MIDDLE_MIN_HEIGHT,
+  DEFAULT_VIRTUALIZED_SECTION_ROW_SMALL_HEIGHT: DEFAULT_VIRTUALIZED_ROW_SMALL_HEIGHT,
+  DEFAULT_VIRTUALIZED_ROW_SMALL_HEIGHT,
+  DEFAULT_VIRTUALIZED_ROW_SMALL_MIN_HEIGHT
+};
+export { cssClasses, strings, numbers };