@join-x5/react-data-grid 1.1.1-nightly → 1.1.3-nightly

package/dist/TableCell/index.es.js

@@ -0,0 +1,234 @@
+"use client";
+import { jsx as Z, jsxs as e } from "@emotion/react/jsx-runtime";
+import W from "@emotion/styled/base";
+import j from "react";
+import { flexRender as r } from "@tanstack/react-table";
+import { SizeTokenValue as A, forwardRef as y, useRefMerge as T } from "@join-x5/react-theme";
+import { EditOnIcon as E } from "@join-x5/react-icons";
+import { ColumnArea as t } from "@join-x5/react-data-grid-settings";
+import { useDataGridTableCell as M } from "./hook.es.js";
+function h() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+const f = {
+  [A.XXSmall]: 8,
+  [A.XSmall]: 8,
+  [A.Small]: 8,
+  [A.Medium]: 12,
+  [A.Large]: 12,
+  [A.XLarge]: 12
+}, P = /* @__PURE__ */ W("td", process.env.NODE_ENV === "production" ? {
+  target: "e1enoxlq3"
+} : {
+  target: "e1enoxlq3",
+  label: "Cell"
+})("position:relative;box-sizing:border-box;height:1px;background-color:var(--background-color, transparent);", (g) => ({
+  color: g.theme.colors.grey[100],
+  "--background-color": g.theme.colors.white,
+  "--border-color": g.theme.colors.grey[10]
+}), ";&[data-", A.Large.toLocaleLowerCase(), "]{min-height:44px;", (g) => g.theme.typography.p1compact, ";}&[data-", A.Medium.toLocaleLowerCase(), "]{min-height:40px;", (g) => g.theme.typography.p2, ";}&[data-", A.Small.toLocaleLowerCase(), "]{min-height:32px;", (g) => g.theme.typography.p2, ";}&[data-", t.FixedLeft.toLocaleLowerCase(), "]{position:sticky;z-index:1;&[data-shadowed][data-last-fixed]{filter:drop-shadow(8px 0px 8px rgba(80, 86, 94, 0.08));}}&[data-", t.FixedRight.toLocaleLowerCase(), "]{position:sticky;z-index:1;&[data-shadowed][data-last-fixed]{filter:drop-shadow(-8px 0px 8px rgba(80, 86, 94, 0.08));}}&[data-row-hover]{", (g) => ({
+  "--background-color": g.theme.colors.grey[10],
+  "--border-color": g.theme.colors.grey[20]
+}), ";}:hover{", (g) => ({
+  "--background-color": g.theme.colors.grey[10],
+  "--border-color": g.theme.colors.grey[40]
+}), ";}:not([data-disabled]):hover::before{border-width:1px;}&[data-disabled]{", (g) => ({
+  color: g.theme.colors.grey[40]
+}), ";:hover{", (g) => ({
+  "--background-color": g.theme.colors.grey[10],
+  "--border-color": g.theme.colors.grey[20]
+}), ";}}&[data-row-selected]{", (g) => ({
+  "--background-color": g.theme.colors.accent[10],
+  "--border-color": g.theme.colors.accent[20]
+}), ";}&[data-focused],:focus{outline:none;", (g) => ({
+  "--border-color": "transparent",
+  "--background-color": g.theme.colors.white,
+  "--outline-color": g.theme.colors.accent[90]
+}), ";::before{display:none;}::after{display:block;}[data-edit-icon]{visibility:visible;}}&[data-active]{outline:none;", (g) => ({
+  "--border-color": "transparent",
+  "--background-color": g.theme.colors.white,
+  "--outline-color": g.theme.colors.accent[90]
+}), ";::before{display:none;}::after{display:block;}[data-edit-icon]{visibility:hidden;}}&[data-error]{", (g) => ({
+  caretColor: g.theme.colors.additional.red[80],
+  "--background-color": g.theme.colors.white,
+  "--border-color": "transparent",
+  "--outline-color": g.theme.colors.additional.red[80]
+}), ";::after{display:block;}}::before{content:'';display:block;position:absolute;box-sizing:border-box;top:0;left:0;width:100%;height:100%;user-select:none;pointer-events:none;border-width:0 0 1px 0;border-style:solid;border-color:var(--border-color);}&[data-bordered]{::before{border-width:0 1px 1px 0;}:last-of-type::before{border-width:0 0 1px 0;}}&[data-resizing]{border-right:1px solid ", (g) => g.theme.colors.accent[20], ";}::after{content:'';display:none;position:absolute;box-sizing:border-box;top:0;left:0;width:100%;height:100%;user-select:none;pointer-events:none;border-width:2px;border-style:solid;border-radius:4px;border-color:var(--outline-color, transparent);}[data-edit-icon]{display:none;position:absolute;visibility:hidden;right:0;top:0;background-color:var(--background-color, transparent);}&[data-editable] [data-edit-icon]{display:block;}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx"],"names":[],"mappings":"AAyBsB","file":"/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx","sourcesContent":["'use client';\n\nimport React from 'react';\nimport styled from '@emotion/styled';\nimport {flexRender} from '@tanstack/react-table';\n\nimport {forwardRef, SizeTokenValue, useRefMerge} from '@join-x5/react-theme';\nimport {EditOnIcon} from '@join-x5/react-icons';\nimport {ColumnArea} from '@join-x5/react-data-grid-settings';\n\nimport {useDataGridTableCell} from './hook';\n\nimport type {HTMLAttributes, KeyboardEventHandler} from 'react';\nimport type {FRC, PropsWithChildren} from '@join-x5/react-theme';\nimport type {DataGridTableCellProps, TableCellProps} from './types';\n\nconst sizePadding: Record<SizeTokenValue, number> = {\n  [SizeTokenValue.XXSmall]: 8,\n  [SizeTokenValue.XSmall]: 8,\n  [SizeTokenValue.Small]: 8,\n  [SizeTokenValue.Medium]: 12,\n  [SizeTokenValue.Large]: 12,\n  [SizeTokenValue.XLarge]: 12,\n};\n\nconst Cell = styled.td`\n  position: relative;\n  box-sizing: border-box;\n  height: 1px;\n  background-color: var(--background-color, transparent);\n\n  ${props => ({\n    color: props.theme.colors.grey[100],\n\n    '--background-color': props.theme.colors.white,\n    '--border-color': props.theme.colors.grey[10],\n  })};\n\n  &[data-${SizeTokenValue.Large.toLocaleLowerCase()}] {\n    min-height: 44px;\n\n    ${props => props.theme.typography.p1compact}\n  }\n\n  &[data-${SizeTokenValue.Medium.toLocaleLowerCase()}] {\n    min-height: 40px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${SizeTokenValue.Small.toLocaleLowerCase()}] {\n    min-height: 32px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${ColumnArea.FixedLeft.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-${ColumnArea.FixedRight.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(-8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-row-hover] {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[20],\n    })}\n  }\n\n  :hover {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[40],\n    })}\n  }\n\n  :not([data-disabled]):hover::before {\n    border-width: 1px;\n  }\n\n  &[data-disabled] {\n    :hover {\n      ${props => ({\n        '--background-color': props.theme.colors.grey[10],\n        '--border-color': props.theme.colors.grey[20],\n      })}\n    }\n\n    ${props => ({\n      color: props.theme.colors.grey[40],\n    })}\n  }\n\n  &[data-row-selected] {\n    ${props => ({\n      '--background-color': props.theme.colors.accent[10],\n      '--border-color': props.theme.colors.accent[20],\n    })}\n  }\n\n  &[data-focused],\n  :focus {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: visible;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-active] {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: hidden;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-error] {\n    ::after {\n      display: block;\n    }\n\n    ${props => ({\n      caretColor: props.theme.colors.additional.red[80],\n\n      '--background-color': props.theme.colors.white,\n      '--border-color': 'transparent',\n      '--outline-color': props.theme.colors.additional.red[80],\n    })}\n  }\n\n  ::before {\n    content: '';\n    display: block;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 0 0 1px 0;\n    border-style: solid;\n    border-color: var(--border-color);\n  }\n\n  &[data-bordered] {\n    ::before {\n      border-width: 0 1px 1px 0;\n    }\n\n    :last-of-type::before {\n      border-width: 0 0 1px 0;\n    }\n  }\n\n  &[data-resizing] {\n    border-right: 1px solid ${props => props.theme.colors.accent[20]};\n  }\n\n  ::after {\n    content: '';\n    display: none;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 2px;\n    border-style: solid;\n    border-radius: 4px;\n    border-color: var(--outline-color, transparent);\n  }\n\n  [data-edit-icon] {\n    display: none;\n    position: absolute;\n    visibility: hidden;\n    right: 0;\n    top: 0;\n    background-color: var(--background-color, transparent);\n  }\n\n  &[data-editable] [data-edit-icon] {\n    display: block;\n  }\n`;\n\nconst Container = styled.div`\n  display: flex;\n  position: relative;\n  box-sizing: border-box;\n  gap: 8px;\n`;\n\nconst Content = styled.div`\n  position: relative;\n  flex-grow: 1;\n  word-break: break-word;\n\n  :not([data-is-multiline]) {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n`;\n\nconst Caption = styled.div`\n  padding: 4px 0 0;\n  width: 100%;\n  word-break: break-all;\n\n  ${props => ({\n    ...props.theme.typography.p3,\n\n    color: props.theme.colors.additional.red[80],\n  })}\n`;\n\ntype TableCellContentProps = Pick<TableCellProps, 'children' | 'isMultiline' | 'whiteSpace' | 'wordBreak'> &\n  HTMLAttributes<HTMLDivElement>;\n\nexport const TableCellContent: FRC<HTMLDivElement, TableCellContentProps> = forwardRef((props, ref) => {\n  const {children, style, isMultiline, whiteSpace, wordBreak = 'break-word', ...rest} = props;\n\n  const contentProps = {\n    ...rest,\n\n    style: {\n      whiteSpace,\n      wordBreak,\n\n      ...style,\n    },\n\n    'data-content': true,\n    'data-is-multiline': isMultiline ? true : undefined,\n  };\n\n  return (\n    <Content ref={ref} {...contentProps}>\n      {children}\n    </Content>\n  );\n});\n\nexport const TableCell: FRC<HTMLTableCellElement, TableCellProps> = forwardRef((props, baseRef) => {\n  const ref = useRefMerge(baseRef);\n\n  const {\n    children,\n\n    isDisabled,\n    isRowHover,\n    isRowSelected,\n    isBordered,\n    isShadowed,\n    isFocused,\n    isActive,\n    isResizing,\n    isLastFixed,\n    error,\n\n    textAlign,\n    writingMode,\n    verticalAlign,\n    padding,\n    userSelect = 'none',\n\n    startAdornment,\n    endAdornment,\n\n    size = SizeTokenValue.Medium,\n    columnArea = ColumnArea.Default,\n\n    ...rest\n  } = props;\n\n  const onKeyDown: KeyboardEventHandler<HTMLTableCellElement> = e => {\n    props.onKeyDown?.(e);\n\n    const isEnterCode = e.code === 'Enter' || e.code === 'NumpadEnter';\n\n    if (isEnterCode) {\n      const child = ref.current?.querySelector('[data-action]') as HTMLElement;\n\n      if (isEnterCode && child) {\n        child.click();\n      }\n\n      return;\n    }\n\n    if (e.code === 'Escape') {\n      ref.current?.blur();\n      return;\n    }\n\n    if (e.code === 'ArrowUp' || e.code === 'ArrowDown' || e.code === 'ArrowLeft' || e.code === 'ArrowRight') {\n      const parent = ref.current?.parentElement as HTMLElement;\n      const curIndex = Array.from(parent?.childNodes).indexOf(ref.current as HTMLElement);\n\n      switch (e.code) {\n        case 'ArrowUp':\n        case 'ArrowDown':\n          {\n            const sibling = (\n              e.code === 'ArrowUp' ? parent?.previousElementSibling : parent?.nextElementSibling\n            ) as HTMLElement;\n\n            if (parent?.nodeName === sibling?.nodeName) {\n              const nextFocus = sibling?.children[curIndex] as HTMLElement;\n\n              nextFocus?.focus();\n            }\n          }\n          break;\n\n        case 'ArrowLeft':\n          if (curIndex > 0) {\n            const prevSibling = parent?.children[curIndex - 1] as HTMLElement;\n            prevSibling?.focus();\n          } else {\n            const prevRow = parent?.previousElementSibling as HTMLElement;\n            if (parent?.nodeName === prevRow?.nodeName) {\n              const lastCell = prevRow.lastElementChild as HTMLElement;\n              lastCell?.focus();\n            }\n          }\n          break;\n        case 'ArrowRight':\n          if (curIndex < parent?.children.length - 1) {\n            const nextSibling = parent?.children[curIndex + 1] as HTMLElement;\n            nextSibling?.focus();\n          } else {\n            const nextRow = parent?.nextElementSibling as HTMLElement;\n            if (parent?.nodeName === nextRow?.nodeName) {\n              const firstCell = nextRow.firstElementChild as HTMLElement;\n              firstCell?.focus();\n            }\n          }\n          break;\n      }\n    }\n  };\n\n  const cellProps = {\n    ...rest,\n\n    onKeyDown,\n\n    style: {\n      verticalAlign,\n      textAlign,\n      writingMode,\n      userSelect,\n\n      padding: padding ?? sizePadding[size],\n\n      ...props.style,\n    },\n\n    'data-cell': true,\n    'data-disabled': isDisabled ? true : undefined,\n    'data-focused': isFocused ? true : undefined,\n    'data-error': error ? true : undefined,\n    'data-row-hover': isRowHover ? true : undefined,\n    'data-row-selected': isRowSelected ? true : undefined,\n    'data-bordered': isBordered ? true : undefined,\n    'data-shadowed': isShadowed ? true : undefined,\n    'data-resizing': isResizing ? true : undefined,\n    'data-active': isActive ? true : undefined,\n    'data-last-fixed': isLastFixed ? true : undefined,\n\n    [`data-${size.toLowerCase()}`]: true,\n    [`data-${columnArea.toLowerCase()}`]: true,\n  };\n\n  const caption = typeof error === 'string' ? <Caption>{error}</Caption> : null;\n\n  return (\n    <Cell ref={ref} tabIndex={0} {...cellProps}>\n      <Container>\n        {startAdornment}\n        {children}\n        {endAdornment}\n        <EditOnIcon data-edit-icon size={SizeTokenValue.Small} />\n      </Container>\n      {caption}\n    </Cell>\n  );\n});\n\nexport const DataGridTableCell: FRC<HTMLTableCellElement, DataGridTableCellProps & PropsWithChildren> = forwardRef(\n  (props, ref) => {\n    const resultProps = useDataGridTableCell(props.cell);\n\n    const contentProps = {\n      isMultiline: resultProps.isMultiline,\n      whiteSpace: resultProps.whiteSpace,\n      wordBreak: resultProps.wordBreak,\n    };\n\n    return (\n      <TableCell ref={ref} {...resultProps}>\n        <TableCellContent {...contentProps}>{props.children}</TableCellContent>\n      </TableCell>\n    );\n  }\n);\n\nexport const getDataGridTableCell = (cell: DataGridTableCellProps['cell']) => {\n  const content = flexRender(cell.column.columnDef.cell, cell.getContext());\n\n  if (cell.column.columnDef.meta?.isCustom) {\n    return <React.Fragment key={cell.id}>{content}</React.Fragment>;\n  }\n\n  return (\n    <DataGridTableCell key={cell.id} cell={cell}>\n      {content}\n    </DataGridTableCell>\n  );\n};\n\nexport * from './types';\n"]} */")), K = /* @__PURE__ */ W("div", process.env.NODE_ENV === "production" ? {
+  target: "e1enoxlq2"
+} : {
+  target: "e1enoxlq2",
+  label: "Container"
+})(process.env.NODE_ENV === "production" ? {
+  name: "15dbgh0",
+  styles: "display:flex;position:relative;box-sizing:border-box;gap:8px"
+} : {
+  name: "15dbgh0",
+  styles: "display:flex;position:relative;box-sizing:border-box;gap:8px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx"],"names":[],"mappings":"AAwO4B","file":"/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx","sourcesContent":["'use client';\n\nimport React from 'react';\nimport styled from '@emotion/styled';\nimport {flexRender} from '@tanstack/react-table';\n\nimport {forwardRef, SizeTokenValue, useRefMerge} from '@join-x5/react-theme';\nimport {EditOnIcon} from '@join-x5/react-icons';\nimport {ColumnArea} from '@join-x5/react-data-grid-settings';\n\nimport {useDataGridTableCell} from './hook';\n\nimport type {HTMLAttributes, KeyboardEventHandler} from 'react';\nimport type {FRC, PropsWithChildren} from '@join-x5/react-theme';\nimport type {DataGridTableCellProps, TableCellProps} from './types';\n\nconst sizePadding: Record<SizeTokenValue, number> = {\n  [SizeTokenValue.XXSmall]: 8,\n  [SizeTokenValue.XSmall]: 8,\n  [SizeTokenValue.Small]: 8,\n  [SizeTokenValue.Medium]: 12,\n  [SizeTokenValue.Large]: 12,\n  [SizeTokenValue.XLarge]: 12,\n};\n\nconst Cell = styled.td`\n  position: relative;\n  box-sizing: border-box;\n  height: 1px;\n  background-color: var(--background-color, transparent);\n\n  ${props => ({\n    color: props.theme.colors.grey[100],\n\n    '--background-color': props.theme.colors.white,\n    '--border-color': props.theme.colors.grey[10],\n  })};\n\n  &[data-${SizeTokenValue.Large.toLocaleLowerCase()}] {\n    min-height: 44px;\n\n    ${props => props.theme.typography.p1compact}\n  }\n\n  &[data-${SizeTokenValue.Medium.toLocaleLowerCase()}] {\n    min-height: 40px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${SizeTokenValue.Small.toLocaleLowerCase()}] {\n    min-height: 32px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${ColumnArea.FixedLeft.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-${ColumnArea.FixedRight.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(-8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-row-hover] {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[20],\n    })}\n  }\n\n  :hover {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[40],\n    })}\n  }\n\n  :not([data-disabled]):hover::before {\n    border-width: 1px;\n  }\n\n  &[data-disabled] {\n    :hover {\n      ${props => ({\n        '--background-color': props.theme.colors.grey[10],\n        '--border-color': props.theme.colors.grey[20],\n      })}\n    }\n\n    ${props => ({\n      color: props.theme.colors.grey[40],\n    })}\n  }\n\n  &[data-row-selected] {\n    ${props => ({\n      '--background-color': props.theme.colors.accent[10],\n      '--border-color': props.theme.colors.accent[20],\n    })}\n  }\n\n  &[data-focused],\n  :focus {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: visible;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-active] {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: hidden;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-error] {\n    ::after {\n      display: block;\n    }\n\n    ${props => ({\n      caretColor: props.theme.colors.additional.red[80],\n\n      '--background-color': props.theme.colors.white,\n      '--border-color': 'transparent',\n      '--outline-color': props.theme.colors.additional.red[80],\n    })}\n  }\n\n  ::before {\n    content: '';\n    display: block;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 0 0 1px 0;\n    border-style: solid;\n    border-color: var(--border-color);\n  }\n\n  &[data-bordered] {\n    ::before {\n      border-width: 0 1px 1px 0;\n    }\n\n    :last-of-type::before {\n      border-width: 0 0 1px 0;\n    }\n  }\n\n  &[data-resizing] {\n    border-right: 1px solid ${props => props.theme.colors.accent[20]};\n  }\n\n  ::after {\n    content: '';\n    display: none;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 2px;\n    border-style: solid;\n    border-radius: 4px;\n    border-color: var(--outline-color, transparent);\n  }\n\n  [data-edit-icon] {\n    display: none;\n    position: absolute;\n    visibility: hidden;\n    right: 0;\n    top: 0;\n    background-color: var(--background-color, transparent);\n  }\n\n  &[data-editable] [data-edit-icon] {\n    display: block;\n  }\n`;\n\nconst Container = styled.div`\n  display: flex;\n  position: relative;\n  box-sizing: border-box;\n  gap: 8px;\n`;\n\nconst Content = styled.div`\n  position: relative;\n  flex-grow: 1;\n  word-break: break-word;\n\n  :not([data-is-multiline]) {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n`;\n\nconst Caption = styled.div`\n  padding: 4px 0 0;\n  width: 100%;\n  word-break: break-all;\n\n  ${props => ({\n    ...props.theme.typography.p3,\n\n    color: props.theme.colors.additional.red[80],\n  })}\n`;\n\ntype TableCellContentProps = Pick<TableCellProps, 'children' | 'isMultiline' | 'whiteSpace' | 'wordBreak'> &\n  HTMLAttributes<HTMLDivElement>;\n\nexport const TableCellContent: FRC<HTMLDivElement, TableCellContentProps> = forwardRef((props, ref) => {\n  const {children, style, isMultiline, whiteSpace, wordBreak = 'break-word', ...rest} = props;\n\n  const contentProps = {\n    ...rest,\n\n    style: {\n      whiteSpace,\n      wordBreak,\n\n      ...style,\n    },\n\n    'data-content': true,\n    'data-is-multiline': isMultiline ? true : undefined,\n  };\n\n  return (\n    <Content ref={ref} {...contentProps}>\n      {children}\n    </Content>\n  );\n});\n\nexport const TableCell: FRC<HTMLTableCellElement, TableCellProps> = forwardRef((props, baseRef) => {\n  const ref = useRefMerge(baseRef);\n\n  const {\n    children,\n\n    isDisabled,\n    isRowHover,\n    isRowSelected,\n    isBordered,\n    isShadowed,\n    isFocused,\n    isActive,\n    isResizing,\n    isLastFixed,\n    error,\n\n    textAlign,\n    writingMode,\n    verticalAlign,\n    padding,\n    userSelect = 'none',\n\n    startAdornment,\n    endAdornment,\n\n    size = SizeTokenValue.Medium,\n    columnArea = ColumnArea.Default,\n\n    ...rest\n  } = props;\n\n  const onKeyDown: KeyboardEventHandler<HTMLTableCellElement> = e => {\n    props.onKeyDown?.(e);\n\n    const isEnterCode = e.code === 'Enter' || e.code === 'NumpadEnter';\n\n    if (isEnterCode) {\n      const child = ref.current?.querySelector('[data-action]') as HTMLElement;\n\n      if (isEnterCode && child) {\n        child.click();\n      }\n\n      return;\n    }\n\n    if (e.code === 'Escape') {\n      ref.current?.blur();\n      return;\n    }\n\n    if (e.code === 'ArrowUp' || e.code === 'ArrowDown' || e.code === 'ArrowLeft' || e.code === 'ArrowRight') {\n      const parent = ref.current?.parentElement as HTMLElement;\n      const curIndex = Array.from(parent?.childNodes).indexOf(ref.current as HTMLElement);\n\n      switch (e.code) {\n        case 'ArrowUp':\n        case 'ArrowDown':\n          {\n            const sibling = (\n              e.code === 'ArrowUp' ? parent?.previousElementSibling : parent?.nextElementSibling\n            ) as HTMLElement;\n\n            if (parent?.nodeName === sibling?.nodeName) {\n              const nextFocus = sibling?.children[curIndex] as HTMLElement;\n\n              nextFocus?.focus();\n            }\n          }\n          break;\n\n        case 'ArrowLeft':\n          if (curIndex > 0) {\n            const prevSibling = parent?.children[curIndex - 1] as HTMLElement;\n            prevSibling?.focus();\n          } else {\n            const prevRow = parent?.previousElementSibling as HTMLElement;\n            if (parent?.nodeName === prevRow?.nodeName) {\n              const lastCell = prevRow.lastElementChild as HTMLElement;\n              lastCell?.focus();\n            }\n          }\n          break;\n        case 'ArrowRight':\n          if (curIndex < parent?.children.length - 1) {\n            const nextSibling = parent?.children[curIndex + 1] as HTMLElement;\n            nextSibling?.focus();\n          } else {\n            const nextRow = parent?.nextElementSibling as HTMLElement;\n            if (parent?.nodeName === nextRow?.nodeName) {\n              const firstCell = nextRow.firstElementChild as HTMLElement;\n              firstCell?.focus();\n            }\n          }\n          break;\n      }\n    }\n  };\n\n  const cellProps = {\n    ...rest,\n\n    onKeyDown,\n\n    style: {\n      verticalAlign,\n      textAlign,\n      writingMode,\n      userSelect,\n\n      padding: padding ?? sizePadding[size],\n\n      ...props.style,\n    },\n\n    'data-cell': true,\n    'data-disabled': isDisabled ? true : undefined,\n    'data-focused': isFocused ? true : undefined,\n    'data-error': error ? true : undefined,\n    'data-row-hover': isRowHover ? true : undefined,\n    'data-row-selected': isRowSelected ? true : undefined,\n    'data-bordered': isBordered ? true : undefined,\n    'data-shadowed': isShadowed ? true : undefined,\n    'data-resizing': isResizing ? true : undefined,\n    'data-active': isActive ? true : undefined,\n    'data-last-fixed': isLastFixed ? true : undefined,\n\n    [`data-${size.toLowerCase()}`]: true,\n    [`data-${columnArea.toLowerCase()}`]: true,\n  };\n\n  const caption = typeof error === 'string' ? <Caption>{error}</Caption> : null;\n\n  return (\n    <Cell ref={ref} tabIndex={0} {...cellProps}>\n      <Container>\n        {startAdornment}\n        {children}\n        {endAdornment}\n        <EditOnIcon data-edit-icon size={SizeTokenValue.Small} />\n      </Container>\n      {caption}\n    </Cell>\n  );\n});\n\nexport const DataGridTableCell: FRC<HTMLTableCellElement, DataGridTableCellProps & PropsWithChildren> = forwardRef(\n  (props, ref) => {\n    const resultProps = useDataGridTableCell(props.cell);\n\n    const contentProps = {\n      isMultiline: resultProps.isMultiline,\n      whiteSpace: resultProps.whiteSpace,\n      wordBreak: resultProps.wordBreak,\n    };\n\n    return (\n      <TableCell ref={ref} {...resultProps}>\n        <TableCellContent {...contentProps}>{props.children}</TableCellContent>\n      </TableCell>\n    );\n  }\n);\n\nexport const getDataGridTableCell = (cell: DataGridTableCellProps['cell']) => {\n  const content = flexRender(cell.column.columnDef.cell, cell.getContext());\n\n  if (cell.column.columnDef.meta?.isCustom) {\n    return <React.Fragment key={cell.id}>{content}</React.Fragment>;\n  }\n\n  return (\n    <DataGridTableCell key={cell.id} cell={cell}>\n      {content}\n    </DataGridTableCell>\n  );\n};\n\nexport * from './types';\n"]} */",
+  toString: h
+}), q = /* @__PURE__ */ W("div", process.env.NODE_ENV === "production" ? {
+  target: "e1enoxlq1"
+} : {
+  target: "e1enoxlq1",
+  label: "Content"
+})(process.env.NODE_ENV === "production" ? {
+  name: "q5vyh6",
+  styles: "position:relative;flex-grow:1;word-break:break-word;:not([data-is-multiline]){overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}"
+} : {
+  name: "q5vyh6",
+  styles: "position:relative;flex-grow:1;word-break:break-word;:not([data-is-multiline]){overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx"],"names":[],"mappings":"AA+O0B","file":"/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx","sourcesContent":["'use client';\n\nimport React from 'react';\nimport styled from '@emotion/styled';\nimport {flexRender} from '@tanstack/react-table';\n\nimport {forwardRef, SizeTokenValue, useRefMerge} from '@join-x5/react-theme';\nimport {EditOnIcon} from '@join-x5/react-icons';\nimport {ColumnArea} from '@join-x5/react-data-grid-settings';\n\nimport {useDataGridTableCell} from './hook';\n\nimport type {HTMLAttributes, KeyboardEventHandler} from 'react';\nimport type {FRC, PropsWithChildren} from '@join-x5/react-theme';\nimport type {DataGridTableCellProps, TableCellProps} from './types';\n\nconst sizePadding: Record<SizeTokenValue, number> = {\n  [SizeTokenValue.XXSmall]: 8,\n  [SizeTokenValue.XSmall]: 8,\n  [SizeTokenValue.Small]: 8,\n  [SizeTokenValue.Medium]: 12,\n  [SizeTokenValue.Large]: 12,\n  [SizeTokenValue.XLarge]: 12,\n};\n\nconst Cell = styled.td`\n  position: relative;\n  box-sizing: border-box;\n  height: 1px;\n  background-color: var(--background-color, transparent);\n\n  ${props => ({\n    color: props.theme.colors.grey[100],\n\n    '--background-color': props.theme.colors.white,\n    '--border-color': props.theme.colors.grey[10],\n  })};\n\n  &[data-${SizeTokenValue.Large.toLocaleLowerCase()}] {\n    min-height: 44px;\n\n    ${props => props.theme.typography.p1compact}\n  }\n\n  &[data-${SizeTokenValue.Medium.toLocaleLowerCase()}] {\n    min-height: 40px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${SizeTokenValue.Small.toLocaleLowerCase()}] {\n    min-height: 32px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${ColumnArea.FixedLeft.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-${ColumnArea.FixedRight.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(-8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-row-hover] {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[20],\n    })}\n  }\n\n  :hover {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[40],\n    })}\n  }\n\n  :not([data-disabled]):hover::before {\n    border-width: 1px;\n  }\n\n  &[data-disabled] {\n    :hover {\n      ${props => ({\n        '--background-color': props.theme.colors.grey[10],\n        '--border-color': props.theme.colors.grey[20],\n      })}\n    }\n\n    ${props => ({\n      color: props.theme.colors.grey[40],\n    })}\n  }\n\n  &[data-row-selected] {\n    ${props => ({\n      '--background-color': props.theme.colors.accent[10],\n      '--border-color': props.theme.colors.accent[20],\n    })}\n  }\n\n  &[data-focused],\n  :focus {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: visible;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-active] {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: hidden;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-error] {\n    ::after {\n      display: block;\n    }\n\n    ${props => ({\n      caretColor: props.theme.colors.additional.red[80],\n\n      '--background-color': props.theme.colors.white,\n      '--border-color': 'transparent',\n      '--outline-color': props.theme.colors.additional.red[80],\n    })}\n  }\n\n  ::before {\n    content: '';\n    display: block;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 0 0 1px 0;\n    border-style: solid;\n    border-color: var(--border-color);\n  }\n\n  &[data-bordered] {\n    ::before {\n      border-width: 0 1px 1px 0;\n    }\n\n    :last-of-type::before {\n      border-width: 0 0 1px 0;\n    }\n  }\n\n  &[data-resizing] {\n    border-right: 1px solid ${props => props.theme.colors.accent[20]};\n  }\n\n  ::after {\n    content: '';\n    display: none;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 2px;\n    border-style: solid;\n    border-radius: 4px;\n    border-color: var(--outline-color, transparent);\n  }\n\n  [data-edit-icon] {\n    display: none;\n    position: absolute;\n    visibility: hidden;\n    right: 0;\n    top: 0;\n    background-color: var(--background-color, transparent);\n  }\n\n  &[data-editable] [data-edit-icon] {\n    display: block;\n  }\n`;\n\nconst Container = styled.div`\n  display: flex;\n  position: relative;\n  box-sizing: border-box;\n  gap: 8px;\n`;\n\nconst Content = styled.div`\n  position: relative;\n  flex-grow: 1;\n  word-break: break-word;\n\n  :not([data-is-multiline]) {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n`;\n\nconst Caption = styled.div`\n  padding: 4px 0 0;\n  width: 100%;\n  word-break: break-all;\n\n  ${props => ({\n    ...props.theme.typography.p3,\n\n    color: props.theme.colors.additional.red[80],\n  })}\n`;\n\ntype TableCellContentProps = Pick<TableCellProps, 'children' | 'isMultiline' | 'whiteSpace' | 'wordBreak'> &\n  HTMLAttributes<HTMLDivElement>;\n\nexport const TableCellContent: FRC<HTMLDivElement, TableCellContentProps> = forwardRef((props, ref) => {\n  const {children, style, isMultiline, whiteSpace, wordBreak = 'break-word', ...rest} = props;\n\n  const contentProps = {\n    ...rest,\n\n    style: {\n      whiteSpace,\n      wordBreak,\n\n      ...style,\n    },\n\n    'data-content': true,\n    'data-is-multiline': isMultiline ? true : undefined,\n  };\n\n  return (\n    <Content ref={ref} {...contentProps}>\n      {children}\n    </Content>\n  );\n});\n\nexport const TableCell: FRC<HTMLTableCellElement, TableCellProps> = forwardRef((props, baseRef) => {\n  const ref = useRefMerge(baseRef);\n\n  const {\n    children,\n\n    isDisabled,\n    isRowHover,\n    isRowSelected,\n    isBordered,\n    isShadowed,\n    isFocused,\n    isActive,\n    isResizing,\n    isLastFixed,\n    error,\n\n    textAlign,\n    writingMode,\n    verticalAlign,\n    padding,\n    userSelect = 'none',\n\n    startAdornment,\n    endAdornment,\n\n    size = SizeTokenValue.Medium,\n    columnArea = ColumnArea.Default,\n\n    ...rest\n  } = props;\n\n  const onKeyDown: KeyboardEventHandler<HTMLTableCellElement> = e => {\n    props.onKeyDown?.(e);\n\n    const isEnterCode = e.code === 'Enter' || e.code === 'NumpadEnter';\n\n    if (isEnterCode) {\n      const child = ref.current?.querySelector('[data-action]') as HTMLElement;\n\n      if (isEnterCode && child) {\n        child.click();\n      }\n\n      return;\n    }\n\n    if (e.code === 'Escape') {\n      ref.current?.blur();\n      return;\n    }\n\n    if (e.code === 'ArrowUp' || e.code === 'ArrowDown' || e.code === 'ArrowLeft' || e.code === 'ArrowRight') {\n      const parent = ref.current?.parentElement as HTMLElement;\n      const curIndex = Array.from(parent?.childNodes).indexOf(ref.current as HTMLElement);\n\n      switch (e.code) {\n        case 'ArrowUp':\n        case 'ArrowDown':\n          {\n            const sibling = (\n              e.code === 'ArrowUp' ? parent?.previousElementSibling : parent?.nextElementSibling\n            ) as HTMLElement;\n\n            if (parent?.nodeName === sibling?.nodeName) {\n              const nextFocus = sibling?.children[curIndex] as HTMLElement;\n\n              nextFocus?.focus();\n            }\n          }\n          break;\n\n        case 'ArrowLeft':\n          if (curIndex > 0) {\n            const prevSibling = parent?.children[curIndex - 1] as HTMLElement;\n            prevSibling?.focus();\n          } else {\n            const prevRow = parent?.previousElementSibling as HTMLElement;\n            if (parent?.nodeName === prevRow?.nodeName) {\n              const lastCell = prevRow.lastElementChild as HTMLElement;\n              lastCell?.focus();\n            }\n          }\n          break;\n        case 'ArrowRight':\n          if (curIndex < parent?.children.length - 1) {\n            const nextSibling = parent?.children[curIndex + 1] as HTMLElement;\n            nextSibling?.focus();\n          } else {\n            const nextRow = parent?.nextElementSibling as HTMLElement;\n            if (parent?.nodeName === nextRow?.nodeName) {\n              const firstCell = nextRow.firstElementChild as HTMLElement;\n              firstCell?.focus();\n            }\n          }\n          break;\n      }\n    }\n  };\n\n  const cellProps = {\n    ...rest,\n\n    onKeyDown,\n\n    style: {\n      verticalAlign,\n      textAlign,\n      writingMode,\n      userSelect,\n\n      padding: padding ?? sizePadding[size],\n\n      ...props.style,\n    },\n\n    'data-cell': true,\n    'data-disabled': isDisabled ? true : undefined,\n    'data-focused': isFocused ? true : undefined,\n    'data-error': error ? true : undefined,\n    'data-row-hover': isRowHover ? true : undefined,\n    'data-row-selected': isRowSelected ? true : undefined,\n    'data-bordered': isBordered ? true : undefined,\n    'data-shadowed': isShadowed ? true : undefined,\n    'data-resizing': isResizing ? true : undefined,\n    'data-active': isActive ? true : undefined,\n    'data-last-fixed': isLastFixed ? true : undefined,\n\n    [`data-${size.toLowerCase()}`]: true,\n    [`data-${columnArea.toLowerCase()}`]: true,\n  };\n\n  const caption = typeof error === 'string' ? <Caption>{error}</Caption> : null;\n\n  return (\n    <Cell ref={ref} tabIndex={0} {...cellProps}>\n      <Container>\n        {startAdornment}\n        {children}\n        {endAdornment}\n        <EditOnIcon data-edit-icon size={SizeTokenValue.Small} />\n      </Container>\n      {caption}\n    </Cell>\n  );\n});\n\nexport const DataGridTableCell: FRC<HTMLTableCellElement, DataGridTableCellProps & PropsWithChildren> = forwardRef(\n  (props, ref) => {\n    const resultProps = useDataGridTableCell(props.cell);\n\n    const contentProps = {\n      isMultiline: resultProps.isMultiline,\n      whiteSpace: resultProps.whiteSpace,\n      wordBreak: resultProps.wordBreak,\n    };\n\n    return (\n      <TableCell ref={ref} {...resultProps}>\n        <TableCellContent {...contentProps}>{props.children}</TableCellContent>\n      </TableCell>\n    );\n  }\n);\n\nexport const getDataGridTableCell = (cell: DataGridTableCellProps['cell']) => {\n  const content = flexRender(cell.column.columnDef.cell, cell.getContext());\n\n  if (cell.column.columnDef.meta?.isCustom) {\n    return <React.Fragment key={cell.id}>{content}</React.Fragment>;\n  }\n\n  return (\n    <DataGridTableCell key={cell.id} cell={cell}>\n      {content}\n    </DataGridTableCell>\n  );\n};\n\nexport * from './types';\n"]} */",
+  toString: h
+}), _ = /* @__PURE__ */ W("div", process.env.NODE_ENV === "production" ? {
+  target: "e1enoxlq0"
+} : {
+  target: "e1enoxlq0",
+  label: "Caption"
+})("padding:4px 0 0;width:100%;word-break:break-all;", (g) => ({
+  ...g.theme.typography.p3,
+  color: g.theme.colors.additional.red[80]
+}), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx"],"names":[],"mappings":"AA2P0B","file":"/home/sadykovsd/join-x5/packages/data-grid/src/TableCell/index.tsx","sourcesContent":["'use client';\n\nimport React from 'react';\nimport styled from '@emotion/styled';\nimport {flexRender} from '@tanstack/react-table';\n\nimport {forwardRef, SizeTokenValue, useRefMerge} from '@join-x5/react-theme';\nimport {EditOnIcon} from '@join-x5/react-icons';\nimport {ColumnArea} from '@join-x5/react-data-grid-settings';\n\nimport {useDataGridTableCell} from './hook';\n\nimport type {HTMLAttributes, KeyboardEventHandler} from 'react';\nimport type {FRC, PropsWithChildren} from '@join-x5/react-theme';\nimport type {DataGridTableCellProps, TableCellProps} from './types';\n\nconst sizePadding: Record<SizeTokenValue, number> = {\n  [SizeTokenValue.XXSmall]: 8,\n  [SizeTokenValue.XSmall]: 8,\n  [SizeTokenValue.Small]: 8,\n  [SizeTokenValue.Medium]: 12,\n  [SizeTokenValue.Large]: 12,\n  [SizeTokenValue.XLarge]: 12,\n};\n\nconst Cell = styled.td`\n  position: relative;\n  box-sizing: border-box;\n  height: 1px;\n  background-color: var(--background-color, transparent);\n\n  ${props => ({\n    color: props.theme.colors.grey[100],\n\n    '--background-color': props.theme.colors.white,\n    '--border-color': props.theme.colors.grey[10],\n  })};\n\n  &[data-${SizeTokenValue.Large.toLocaleLowerCase()}] {\n    min-height: 44px;\n\n    ${props => props.theme.typography.p1compact}\n  }\n\n  &[data-${SizeTokenValue.Medium.toLocaleLowerCase()}] {\n    min-height: 40px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${SizeTokenValue.Small.toLocaleLowerCase()}] {\n    min-height: 32px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${ColumnArea.FixedLeft.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-${ColumnArea.FixedRight.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(-8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-row-hover] {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[20],\n    })}\n  }\n\n  :hover {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[40],\n    })}\n  }\n\n  :not([data-disabled]):hover::before {\n    border-width: 1px;\n  }\n\n  &[data-disabled] {\n    :hover {\n      ${props => ({\n        '--background-color': props.theme.colors.grey[10],\n        '--border-color': props.theme.colors.grey[20],\n      })}\n    }\n\n    ${props => ({\n      color: props.theme.colors.grey[40],\n    })}\n  }\n\n  &[data-row-selected] {\n    ${props => ({\n      '--background-color': props.theme.colors.accent[10],\n      '--border-color': props.theme.colors.accent[20],\n    })}\n  }\n\n  &[data-focused],\n  :focus {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: visible;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-active] {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: hidden;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-error] {\n    ::after {\n      display: block;\n    }\n\n    ${props => ({\n      caretColor: props.theme.colors.additional.red[80],\n\n      '--background-color': props.theme.colors.white,\n      '--border-color': 'transparent',\n      '--outline-color': props.theme.colors.additional.red[80],\n    })}\n  }\n\n  ::before {\n    content: '';\n    display: block;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 0 0 1px 0;\n    border-style: solid;\n    border-color: var(--border-color);\n  }\n\n  &[data-bordered] {\n    ::before {\n      border-width: 0 1px 1px 0;\n    }\n\n    :last-of-type::before {\n      border-width: 0 0 1px 0;\n    }\n  }\n\n  &[data-resizing] {\n    border-right: 1px solid ${props => props.theme.colors.accent[20]};\n  }\n\n  ::after {\n    content: '';\n    display: none;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 2px;\n    border-style: solid;\n    border-radius: 4px;\n    border-color: var(--outline-color, transparent);\n  }\n\n  [data-edit-icon] {\n    display: none;\n    position: absolute;\n    visibility: hidden;\n    right: 0;\n    top: 0;\n    background-color: var(--background-color, transparent);\n  }\n\n  &[data-editable] [data-edit-icon] {\n    display: block;\n  }\n`;\n\nconst Container = styled.div`\n  display: flex;\n  position: relative;\n  box-sizing: border-box;\n  gap: 8px;\n`;\n\nconst Content = styled.div`\n  position: relative;\n  flex-grow: 1;\n  word-break: break-word;\n\n  :not([data-is-multiline]) {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n`;\n\nconst Caption = styled.div`\n  padding: 4px 0 0;\n  width: 100%;\n  word-break: break-all;\n\n  ${props => ({\n    ...props.theme.typography.p3,\n\n    color: props.theme.colors.additional.red[80],\n  })}\n`;\n\ntype TableCellContentProps = Pick<TableCellProps, 'children' | 'isMultiline' | 'whiteSpace' | 'wordBreak'> &\n  HTMLAttributes<HTMLDivElement>;\n\nexport const TableCellContent: FRC<HTMLDivElement, TableCellContentProps> = forwardRef((props, ref) => {\n  const {children, style, isMultiline, whiteSpace, wordBreak = 'break-word', ...rest} = props;\n\n  const contentProps = {\n    ...rest,\n\n    style: {\n      whiteSpace,\n      wordBreak,\n\n      ...style,\n    },\n\n    'data-content': true,\n    'data-is-multiline': isMultiline ? true : undefined,\n  };\n\n  return (\n    <Content ref={ref} {...contentProps}>\n      {children}\n    </Content>\n  );\n});\n\nexport const TableCell: FRC<HTMLTableCellElement, TableCellProps> = forwardRef((props, baseRef) => {\n  const ref = useRefMerge(baseRef);\n\n  const {\n    children,\n\n    isDisabled,\n    isRowHover,\n    isRowSelected,\n    isBordered,\n    isShadowed,\n    isFocused,\n    isActive,\n    isResizing,\n    isLastFixed,\n    error,\n\n    textAlign,\n    writingMode,\n    verticalAlign,\n    padding,\n    userSelect = 'none',\n\n    startAdornment,\n    endAdornment,\n\n    size = SizeTokenValue.Medium,\n    columnArea = ColumnArea.Default,\n\n    ...rest\n  } = props;\n\n  const onKeyDown: KeyboardEventHandler<HTMLTableCellElement> = e => {\n    props.onKeyDown?.(e);\n\n    const isEnterCode = e.code === 'Enter' || e.code === 'NumpadEnter';\n\n    if (isEnterCode) {\n      const child = ref.current?.querySelector('[data-action]') as HTMLElement;\n\n      if (isEnterCode && child) {\n        child.click();\n      }\n\n      return;\n    }\n\n    if (e.code === 'Escape') {\n      ref.current?.blur();\n      return;\n    }\n\n    if (e.code === 'ArrowUp' || e.code === 'ArrowDown' || e.code === 'ArrowLeft' || e.code === 'ArrowRight') {\n      const parent = ref.current?.parentElement as HTMLElement;\n      const curIndex = Array.from(parent?.childNodes).indexOf(ref.current as HTMLElement);\n\n      switch (e.code) {\n        case 'ArrowUp':\n        case 'ArrowDown':\n          {\n            const sibling = (\n              e.code === 'ArrowUp' ? parent?.previousElementSibling : parent?.nextElementSibling\n            ) as HTMLElement;\n\n            if (parent?.nodeName === sibling?.nodeName) {\n              const nextFocus = sibling?.children[curIndex] as HTMLElement;\n\n              nextFocus?.focus();\n            }\n          }\n          break;\n\n        case 'ArrowLeft':\n          if (curIndex > 0) {\n            const prevSibling = parent?.children[curIndex - 1] as HTMLElement;\n            prevSibling?.focus();\n          } else {\n            const prevRow = parent?.previousElementSibling as HTMLElement;\n            if (parent?.nodeName === prevRow?.nodeName) {\n              const lastCell = prevRow.lastElementChild as HTMLElement;\n              lastCell?.focus();\n            }\n          }\n          break;\n        case 'ArrowRight':\n          if (curIndex < parent?.children.length - 1) {\n            const nextSibling = parent?.children[curIndex + 1] as HTMLElement;\n            nextSibling?.focus();\n          } else {\n            const nextRow = parent?.nextElementSibling as HTMLElement;\n            if (parent?.nodeName === nextRow?.nodeName) {\n              const firstCell = nextRow.firstElementChild as HTMLElement;\n              firstCell?.focus();\n            }\n          }\n          break;\n      }\n    }\n  };\n\n  const cellProps = {\n    ...rest,\n\n    onKeyDown,\n\n    style: {\n      verticalAlign,\n      textAlign,\n      writingMode,\n      userSelect,\n\n      padding: padding ?? sizePadding[size],\n\n      ...props.style,\n    },\n\n    'data-cell': true,\n    'data-disabled': isDisabled ? true : undefined,\n    'data-focused': isFocused ? true : undefined,\n    'data-error': error ? true : undefined,\n    'data-row-hover': isRowHover ? true : undefined,\n    'data-row-selected': isRowSelected ? true : undefined,\n    'data-bordered': isBordered ? true : undefined,\n    'data-shadowed': isShadowed ? true : undefined,\n    'data-resizing': isResizing ? true : undefined,\n    'data-active': isActive ? true : undefined,\n    'data-last-fixed': isLastFixed ? true : undefined,\n\n    [`data-${size.toLowerCase()}`]: true,\n    [`data-${columnArea.toLowerCase()}`]: true,\n  };\n\n  const caption = typeof error === 'string' ? <Caption>{error}</Caption> : null;\n\n  return (\n    <Cell ref={ref} tabIndex={0} {...cellProps}>\n      <Container>\n        {startAdornment}\n        {children}\n        {endAdornment}\n        <EditOnIcon data-edit-icon size={SizeTokenValue.Small} />\n      </Container>\n      {caption}\n    </Cell>\n  );\n});\n\nexport const DataGridTableCell: FRC<HTMLTableCellElement, DataGridTableCellProps & PropsWithChildren> = forwardRef(\n  (props, ref) => {\n    const resultProps = useDataGridTableCell(props.cell);\n\n    const contentProps = {\n      isMultiline: resultProps.isMultiline,\n      whiteSpace: resultProps.whiteSpace,\n      wordBreak: resultProps.wordBreak,\n    };\n\n    return (\n      <TableCell ref={ref} {...resultProps}>\n        <TableCellContent {...contentProps}>{props.children}</TableCellContent>\n      </TableCell>\n    );\n  }\n);\n\nexport const getDataGridTableCell = (cell: DataGridTableCellProps['cell']) => {\n  const content = flexRender(cell.column.columnDef.cell, cell.getContext());\n\n  if (cell.column.columnDef.meta?.isCustom) {\n    return <React.Fragment key={cell.id}>{content}</React.Fragment>;\n  }\n\n  return (\n    <DataGridTableCell key={cell.id} cell={cell}>\n      {content}\n    </DataGridTableCell>\n  );\n};\n\nexport * from './types';\n"]} */")), $ = y((g, l) => {
+  const {
+    children: c,
+    style: d,
+    isMultiline: X,
+    whiteSpace: m,
+    wordBreak: x = "break-word",
+    ...i
+  } = g, V = {
+    ...i,
+    style: {
+      whiteSpace: m,
+      wordBreak: x,
+      ...d
+    },
+    "data-content": !0,
+    "data-is-multiline": X ? !0 : void 0
+  };
+  return /* @__PURE__ */ Z(q, { ref: l, ...V, children: c });
+}), gg = y((g, l) => {
+  const c = T(l), {
+    children: d,
+    isDisabled: X,
+    isRowHover: m,
+    isRowSelected: x,
+    isBordered: i,
+    isShadowed: V,
+    isFocused: o,
+    isActive: F,
+    isResizing: s,
+    isLastFixed: p,
+    error: B,
+    textAlign: v,
+    writingMode: N,
+    verticalAlign: L,
+    padding: z,
+    userSelect: S = "none",
+    startAdornment: D,
+    endAdornment: k,
+    size: R = A.Medium,
+    columnArea: w = t.Default,
+    ...U
+  } = g, Q = {
+    ...U,
+    onKeyDown: (G) => {
+      var J, Y, H, a;
+      (J = g.onKeyDown) == null || J.call(g, G);
+      const n = G.code === "Enter" || G.code === "NumpadEnter";
+      if (n) {
+        const I = (Y = c.current) == null ? void 0 : Y.querySelector("[data-action]");
+        n && I && I.click();
+        return;
+      }
+      if (G.code === "Escape") {
+        (H = c.current) == null || H.blur();
+        return;
+      }
+      if (G.code === "ArrowUp" || G.code === "ArrowDown" || G.code === "ArrowLeft" || G.code === "ArrowRight") {
+        const I = (a = c.current) == null ? void 0 : a.parentElement, u = Array.from(I == null ? void 0 : I.childNodes).indexOf(c.current);
+        switch (G.code) {
+          case "ArrowUp":
+          case "ArrowDown":
+            {
+              const b = G.code === "ArrowUp" ? I == null ? void 0 : I.previousElementSibling : I == null ? void 0 : I.nextElementSibling;
+              if ((I == null ? void 0 : I.nodeName) === (b == null ? void 0 : b.nodeName)) {
+                const C = b == null ? void 0 : b.children[u];
+                C == null || C.focus();
+              }
+            }
+            break;
+          case "ArrowLeft":
+            if (u > 0) {
+              const b = I == null ? void 0 : I.children[u - 1];
+              b == null || b.focus();
+            } else {
+              const b = I == null ? void 0 : I.previousElementSibling;
+              if ((I == null ? void 0 : I.nodeName) === (b == null ? void 0 : b.nodeName)) {
+                const C = b.lastElementChild;
+                C == null || C.focus();
+              }
+            }
+            break;
+          case "ArrowRight":
+            if (u < (I == null ? void 0 : I.children.length) - 1) {
+              const b = I == null ? void 0 : I.children[u + 1];
+              b == null || b.focus();
+            } else {
+              const b = I == null ? void 0 : I.nextElementSibling;
+              if ((I == null ? void 0 : I.nodeName) === (b == null ? void 0 : b.nodeName)) {
+                const C = b.firstElementChild;
+                C == null || C.focus();
+              }
+            }
+            break;
+        }
+      }
+    },
+    style: {
+      verticalAlign: L,
+      textAlign: v,
+      writingMode: N,
+      userSelect: S,
+      padding: z ?? f[R],
+      ...g.style
+    },
+    "data-cell": !0,
+    "data-disabled": X ? !0 : void 0,
+    "data-focused": o ? !0 : void 0,
+    "data-error": B ? !0 : void 0,
+    "data-row-hover": m ? !0 : void 0,
+    "data-row-selected": x ? !0 : void 0,
+    "data-bordered": i ? !0 : void 0,
+    "data-shadowed": V ? !0 : void 0,
+    "data-resizing": s ? !0 : void 0,
+    "data-active": F ? !0 : void 0,
+    "data-last-fixed": p ? !0 : void 0,
+    [`data-${R.toLowerCase()}`]: !0,
+    [`data-${w.toLowerCase()}`]: !0
+  }, O = typeof B == "string" ? /* @__PURE__ */ Z(_, { children: B }) : null;
+  return /* @__PURE__ */ e(P, { ref: c, tabIndex: 0, ...Q, children: [
+    /* @__PURE__ */ e(K, { children: [
+      D,
+      d,
+      k,
+      /* @__PURE__ */ Z(E, { "data-edit-icon": !0, size: A.Small })
+    ] }),
+    O
+  ] });
+}), Ig = y((g, l) => {
+  const c = M(g.cell), d = {
+    isMultiline: c.isMultiline,
+    whiteSpace: c.whiteSpace,
+    wordBreak: c.wordBreak
+  };
+  return /* @__PURE__ */ Z(gg, { ref: l, ...c, children: /* @__PURE__ */ Z($, { ...d, children: g.children }) });
+}), Wg = (g) => {
+  var c;
+  const l = r(g.column.columnDef.cell, g.getContext());
+  return (c = g.column.columnDef.meta) != null && c.isCustom ? /* @__PURE__ */ Z(j.Fragment, { children: l }, g.id) : /* @__PURE__ */ Z(Ig, { cell: g, children: l }, g.id);
+};
+export {
+  Ig as DataGridTableCell,
+  gg as TableCell,
+  $ as TableCellContent,
+  Wg as getDataGridTableCell
+};
+//# sourceMappingURL=index.es.js.map

package/dist/TableCell/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../src/TableCell/index.tsx"],"sourcesContent":["'use client';\n\nimport React from 'react';\nimport styled from '@emotion/styled';\nimport {flexRender} from '@tanstack/react-table';\n\nimport {forwardRef, SizeTokenValue, useRefMerge} from '@join-x5/react-theme';\nimport {EditOnIcon} from '@join-x5/react-icons';\nimport {ColumnArea} from '@join-x5/react-data-grid-settings';\n\nimport {useDataGridTableCell} from './hook';\n\nimport type {HTMLAttributes, KeyboardEventHandler} from 'react';\nimport type {FRC, PropsWithChildren} from '@join-x5/react-theme';\nimport type {DataGridTableCellProps, TableCellProps} from './types';\n\nconst sizePadding: Record<SizeTokenValue, number> = {\n  [SizeTokenValue.XXSmall]: 8,\n  [SizeTokenValue.XSmall]: 8,\n  [SizeTokenValue.Small]: 8,\n  [SizeTokenValue.Medium]: 12,\n  [SizeTokenValue.Large]: 12,\n  [SizeTokenValue.XLarge]: 12,\n};\n\nconst Cell = styled.td`\n  position: relative;\n  box-sizing: border-box;\n  height: 1px;\n  background-color: var(--background-color, transparent);\n\n  ${props => ({\n    color: props.theme.colors.grey[100],\n\n    '--background-color': props.theme.colors.white,\n    '--border-color': props.theme.colors.grey[10],\n  })};\n\n  &[data-${SizeTokenValue.Large.toLocaleLowerCase()}] {\n    min-height: 44px;\n\n    ${props => props.theme.typography.p1compact}\n  }\n\n  &[data-${SizeTokenValue.Medium.toLocaleLowerCase()}] {\n    min-height: 40px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${SizeTokenValue.Small.toLocaleLowerCase()}] {\n    min-height: 32px;\n\n    ${props => props.theme.typography.p2}\n  }\n\n  &[data-${ColumnArea.FixedLeft.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-${ColumnArea.FixedRight.toLocaleLowerCase()}] {\n    position: sticky;\n    z-index: 1;\n\n    &[data-shadowed][data-last-fixed] {\n      filter: drop-shadow(-8px 0px 8px rgba(80, 86, 94, 0.08));\n    }\n  }\n\n  &[data-row-hover] {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[20],\n    })}\n  }\n\n  :hover {\n    ${props => ({\n      '--background-color': props.theme.colors.grey[10],\n      '--border-color': props.theme.colors.grey[40],\n    })}\n  }\n\n  :not([data-disabled]):hover::before {\n    border-width: 1px;\n  }\n\n  &[data-disabled] {\n    :hover {\n      ${props => ({\n        '--background-color': props.theme.colors.grey[10],\n        '--border-color': props.theme.colors.grey[20],\n      })}\n    }\n\n    ${props => ({\n      color: props.theme.colors.grey[40],\n    })}\n  }\n\n  &[data-row-selected] {\n    ${props => ({\n      '--background-color': props.theme.colors.accent[10],\n      '--border-color': props.theme.colors.accent[20],\n    })}\n  }\n\n  &[data-focused],\n  :focus {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: visible;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-active] {\n    outline: none;\n\n    ::before {\n      display: none;\n    }\n\n    ::after {\n      display: block;\n    }\n\n    [data-edit-icon] {\n      visibility: hidden;\n    }\n\n    ${props => ({\n      '--border-color': 'transparent',\n      '--background-color': props.theme.colors.white,\n      '--outline-color': props.theme.colors.accent[90],\n    })}\n  }\n\n  &[data-error] {\n    ::after {\n      display: block;\n    }\n\n    ${props => ({\n      caretColor: props.theme.colors.additional.red[80],\n\n      '--background-color': props.theme.colors.white,\n      '--border-color': 'transparent',\n      '--outline-color': props.theme.colors.additional.red[80],\n    })}\n  }\n\n  ::before {\n    content: '';\n    display: block;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 0 0 1px 0;\n    border-style: solid;\n    border-color: var(--border-color);\n  }\n\n  &[data-bordered] {\n    ::before {\n      border-width: 0 1px 1px 0;\n    }\n\n    :last-of-type::before {\n      border-width: 0 0 1px 0;\n    }\n  }\n\n  &[data-resizing] {\n    border-right: 1px solid ${props => props.theme.colors.accent[20]};\n  }\n\n  ::after {\n    content: '';\n    display: none;\n    position: absolute;\n    box-sizing: border-box;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    user-select: none;\n    pointer-events: none;\n    border-width: 2px;\n    border-style: solid;\n    border-radius: 4px;\n    border-color: var(--outline-color, transparent);\n  }\n\n  [data-edit-icon] {\n    display: none;\n    position: absolute;\n    visibility: hidden;\n    right: 0;\n    top: 0;\n    background-color: var(--background-color, transparent);\n  }\n\n  &[data-editable] [data-edit-icon] {\n    display: block;\n  }\n`;\n\nconst Container = styled.div`\n  display: flex;\n  position: relative;\n  box-sizing: border-box;\n  gap: 8px;\n`;\n\nconst Content = styled.div`\n  position: relative;\n  flex-grow: 1;\n  word-break: break-word;\n\n  :not([data-is-multiline]) {\n    overflow: hidden;\n    text-overflow: ellipsis;\n    white-space: nowrap;\n  }\n`;\n\nconst Caption = styled.div`\n  padding: 4px 0 0;\n  width: 100%;\n  word-break: break-all;\n\n  ${props => ({\n    ...props.theme.typography.p3,\n\n    color: props.theme.colors.additional.red[80],\n  })}\n`;\n\ntype TableCellContentProps = Pick<TableCellProps, 'children' | 'isMultiline' | 'whiteSpace' | 'wordBreak'> &\n  HTMLAttributes<HTMLDivElement>;\n\nexport const TableCellContent: FRC<HTMLDivElement, TableCellContentProps> = forwardRef((props, ref) => {\n  const {children, style, isMultiline, whiteSpace, wordBreak = 'break-word', ...rest} = props;\n\n  const contentProps = {\n    ...rest,\n\n    style: {\n      whiteSpace,\n      wordBreak,\n\n      ...style,\n    },\n\n    'data-content': true,\n    'data-is-multiline': isMultiline ? true : undefined,\n  };\n\n  return (\n    <Content ref={ref} {...contentProps}>\n      {children}\n    </Content>\n  );\n});\n\nexport const TableCell: FRC<HTMLTableCellElement, TableCellProps> = forwardRef((props, baseRef) => {\n  const ref = useRefMerge(baseRef);\n\n  const {\n    children,\n\n    isDisabled,\n    isRowHover,\n    isRowSelected,\n    isBordered,\n    isShadowed,\n    isFocused,\n    isActive,\n    isResizing,\n    isLastFixed,\n    error,\n\n    textAlign,\n    writingMode,\n    verticalAlign,\n    padding,\n    userSelect = 'none',\n\n    startAdornment,\n    endAdornment,\n\n    size = SizeTokenValue.Medium,\n    columnArea = ColumnArea.Default,\n\n    ...rest\n  } = props;\n\n  const onKeyDown: KeyboardEventHandler<HTMLTableCellElement> = e => {\n    props.onKeyDown?.(e);\n\n    const isEnterCode = e.code === 'Enter' || e.code === 'NumpadEnter';\n\n    if (isEnterCode) {\n      const child = ref.current?.querySelector('[data-action]') as HTMLElement;\n\n      if (isEnterCode && child) {\n        child.click();\n      }\n\n      return;\n    }\n\n    if (e.code === 'Escape') {\n      ref.current?.blur();\n      return;\n    }\n\n    if (e.code === 'ArrowUp' || e.code === 'ArrowDown' || e.code === 'ArrowLeft' || e.code === 'ArrowRight') {\n      const parent = ref.current?.parentElement as HTMLElement;\n      const curIndex = Array.from(parent?.childNodes).indexOf(ref.current as HTMLElement);\n\n      switch (e.code) {\n        case 'ArrowUp':\n        case 'ArrowDown':\n          {\n            const sibling = (\n              e.code === 'ArrowUp' ? parent?.previousElementSibling : parent?.nextElementSibling\n            ) as HTMLElement;\n\n            if (parent?.nodeName === sibling?.nodeName) {\n              const nextFocus = sibling?.children[curIndex] as HTMLElement;\n\n              nextFocus?.focus();\n            }\n          }\n          break;\n\n        case 'ArrowLeft':\n          if (curIndex > 0) {\n            const prevSibling = parent?.children[curIndex - 1] as HTMLElement;\n            prevSibling?.focus();\n          } else {\n            const prevRow = parent?.previousElementSibling as HTMLElement;\n            if (parent?.nodeName === prevRow?.nodeName) {\n              const lastCell = prevRow.lastElementChild as HTMLElement;\n              lastCell?.focus();\n            }\n          }\n          break;\n        case 'ArrowRight':\n          if (curIndex < parent?.children.length - 1) {\n            const nextSibling = parent?.children[curIndex + 1] as HTMLElement;\n            nextSibling?.focus();\n          } else {\n            const nextRow = parent?.nextElementSibling as HTMLElement;\n            if (parent?.nodeName === nextRow?.nodeName) {\n              const firstCell = nextRow.firstElementChild as HTMLElement;\n              firstCell?.focus();\n            }\n          }\n          break;\n      }\n    }\n  };\n\n  const cellProps = {\n    ...rest,\n\n    onKeyDown,\n\n    style: {\n      verticalAlign,\n      textAlign,\n      writingMode,\n      userSelect,\n\n      padding: padding ?? sizePadding[size],\n\n      ...props.style,\n    },\n\n    'data-cell': true,\n    'data-disabled': isDisabled ? true : undefined,\n    'data-focused': isFocused ? true : undefined,\n    'data-error': error ? true : undefined,\n    'data-row-hover': isRowHover ? true : undefined,\n    'data-row-selected': isRowSelected ? true : undefined,\n    'data-bordered': isBordered ? true : undefined,\n    'data-shadowed': isShadowed ? true : undefined,\n    'data-resizing': isResizing ? true : undefined,\n    'data-active': isActive ? true : undefined,\n    'data-last-fixed': isLastFixed ? true : undefined,\n\n    [`data-${size.toLowerCase()}`]: true,\n    [`data-${columnArea.toLowerCase()}`]: true,\n  };\n\n  const caption = typeof error === 'string' ? <Caption>{error}</Caption> : null;\n\n  return (\n    <Cell ref={ref} tabIndex={0} {...cellProps}>\n      <Container>\n        {startAdornment}\n        {children}\n        {endAdornment}\n        <EditOnIcon data-edit-icon size={SizeTokenValue.Small} />\n      </Container>\n      {caption}\n    </Cell>\n  );\n});\n\nexport const DataGridTableCell: FRC<HTMLTableCellElement, DataGridTableCellProps & PropsWithChildren> = forwardRef(\n  (props, ref) => {\n    const resultProps = useDataGridTableCell(props.cell);\n\n    const contentProps = {\n      isMultiline: resultProps.isMultiline,\n      whiteSpace: resultProps.whiteSpace,\n      wordBreak: resultProps.wordBreak,\n    };\n\n    return (\n      <TableCell ref={ref} {...resultProps}>\n        <TableCellContent {...contentProps}>{props.children}</TableCellContent>\n      </TableCell>\n    );\n  }\n);\n\nexport const getDataGridTableCell = (cell: DataGridTableCellProps['cell']) => {\n  const content = flexRender(cell.column.columnDef.cell, cell.getContext());\n\n  if (cell.column.columnDef.meta?.isCustom) {\n    return <React.Fragment key={cell.id}>{content}</React.Fragment>;\n  }\n\n  return (\n    <DataGridTableCell key={cell.id} cell={cell}>\n      {content}\n    </DataGridTableCell>\n  );\n};\n\nexport * from './types';\n"],"names":["white","p3","children","style","isMultiline","whiteSpace","rest","wordBreak","undefined","ref","isDisabled","isRowHover","isRowSelected","isBordered","isShadowed","isFocused","isActive","isResizing","isLastFixed","error","textAlign","writingMode","verticalAlign","padding","startAdornment","endAdornment","Medium","Default","props","e","parent","nextFocus","focus","prevSibling","lastCell","nextSibling","firstCell","userSelect","caption","resultProps","content"],"mappings":";;;;;;;;;AAAa;AAAA;AAAA;AAgBb;AAAoD;AACxB;AACD;AACD;AACC;AACD;AAE1B;AAEU;AAAA;AAAA;AAAA;AAAA;AAMI;AACwB;AAEOA;AAE3C;AAuCc;AACsC;AAElD;AAIY;AACsC;AAElD;AAeY;AAEZ;AARc;AACsC;AAElD;AASU;AACwC;AAEpD;AAmBY;AACQ;AACuBA;AAE3C;AAkBY;AACQ;AACuBA;AAE3C;AAQY;AACsC;AAEPA;AACvB;AAEpB;AAgEW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA;AAAA;AAAA;AAAA;AAAA;AAKC;AACgBC;AAG5B;AAOM;AAAA;AAACC;AAAUC;AAAOC;AAAaC;AAAwB;AAAiBC;AAEzD;AAChBA;AAEI;AACLD;AACAE;AAEGJ;AACL;AAEgB;AAC0BK;AAG5C;AAKF;AAGQC;AAEA;AACJP;AAEAQ;AACAC;AACAC;AACAC;AACAC;AACAC;AACAC;AACAC;AACAC;AACAC;AAEAC;AACAC;AACAC;AACAC;AACa;AAEbC;AACAC;AAEsBC;AACEC;AAErBrB;AAuEa;AACbA;;AApEHsB;AAEA;AAEA;AACE;AAEA;AAIA;AAAA;AAGEC;AACFpB;AACA;AAAA;AAGEoB;AACIC;AAGN;AAAc;AACP;AAEH;AACE;AAIIA;AACIC;AAENA;AAAWC;AAAM;AAGrB;AAAA;AAGA;AACE;AACAC;AAAaD;AAEb;AACIF;AACF;AACAI;AAAUF;AAAM;AAGpB;AAAA;AAEA;AACE;AACAG;AAAaH;AAEb;AACIF;AACF;AACAM;AAAWJ;AAAM;AAGrB;AAAA;AAAA;AACJ;AAEJ;AAOS;AACLV;AACAF;AACAC;AACAgB;AAEoC;AAE3BlC;AACX;AAEa;AACwBK;AACFA;AACNA;AACSA;AACMA;AACPA;AACAA;AACAA;AACJA;AACOA;AAER;AACM;AAKxC;AAEI;AACGgB;AAAAA;AACAtB;AACAuB;AACqD;AACxD;AACCa;AAGP;AAIUC;AAEe;AACMnC;AACDC;AACDE;AAIvB;AAIJ;;AAIMiC;AAEN;AASF;;;;;;;"}

package/dist/TableCell/types.d.ts

@@ -0,0 +1,46 @@
+import { SizeTokenValue, CSSProperties, QA } from '@join-x5/react-theme';
+import { ColumnArea } from '@join-x5/react-data-grid-settings';
+import { Cell as ReactTableCell } from '@tanstack/react-table';
+import { ReactNode, TdHTMLAttributes } from 'react';
+type DefaultAny = any;
+export type TableCellProps = {
+    /** Размер */
+    size?: SizeTokenValue | `${SizeTokenValue}`;
+    /** Установка состояния "Отключен" */
+    isDisabled?: boolean;
+    /** Установка состояния "В фокусе" */
+    isFocused?: boolean;
+    /** Установка состояния строки "Hover" */
+    isRowHover?: boolean;
+    /** Установка состояния строки "Выбрана" */
+    isRowSelected?: boolean;
+    /** Установка состояния "Изменение размера" */
+    isResizing?: boolean;
+    /** Расположение колонки */
+    columnArea?: ColumnArea;
+    /** Последняя закрепленная колонка
+     *
+     * Добавляет тень в зависимости от `columnArea`
+     */
+    isLastFixed?: boolean;
+    /** Установка состояния "Активен" */
+    isActive?: boolean;
+    /** Обрабочик установки состояния "Активен" */
+    setIsActive?: (isActive: boolean) => void;
+    /** С границей */
+    isBordered?: boolean;
+    /** Многострочная */
+    isMultiline?: boolean;
+    /** Показывать тень вместо границы, в закрепленных столбцах и шапке */
+    isShadowed?: boolean;
+    /** Ошибка в поле */
+    error?: boolean | ReactNode;
+    /** Иконка | Контент слева */
+    startAdornment?: ReactNode;
+    /** Иконка | Контент справа */
+    endAdornment?: ReactNode;
+} & QA & Pick<CSSProperties, 'padding' | 'verticalAlign' | 'textAlign' | 'writingMode' | 'userSelect' | 'wordBreak' | 'whiteSpace'> & TdHTMLAttributes<HTMLTableCellElement>;
+export type DataGridTableCellProps<T = DefaultAny, V = DefaultAny> = {
+    cell: ReactTableCell<T, V>;
+};
+export {};

package/dist/TableDropdown/index.d.ts

@@ -0,0 +1,8 @@
+export declare const TableDropdownHeader: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableDropdownItem: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/TableDropdown/index.es.js

@@ -0,0 +1,26 @@
+import b from "@emotion/styled/base";
+const g = /* @__PURE__ */ b("div", process.env.NODE_ENV === "production" ? {
+  target: "enkh3l21"
+} : {
+  target: "enkh3l21",
+  label: "TableDropdownHeader"
+})("padding:8px 12px 4px;user-select:none;", (c) => ({
+  ...c.theme.typography.h6,
+  color: c.theme.colors.grey[70]
+}), ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3NhZHlrb3ZzZC9qb2luLXg1L3BhY2thZ2VzL2RhdGEtZ3JpZC9zcmMvVGFibGVEcm9wZG93bi9pbmRleC50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRTZDIiwiZmlsZSI6Ii9ob21lL3NhZHlrb3ZzZC9qb2luLXg1L3BhY2thZ2VzL2RhdGEtZ3JpZC9zcmMvVGFibGVEcm9wZG93bi9pbmRleC50c3giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBUYWJsZURyb3Bkb3duSGVhZGVyID0gc3R5bGVkLmRpdmBcbiAgcGFkZGluZzogOHB4IDEycHggNHB4O1xuICB1c2VyLXNlbGVjdDogbm9uZTtcblxuICAke3Byb3BzID0+ICh7XG4gICAgLi4ucHJvcHMudGhlbWUudHlwb2dyYXBoeS5oNixcblxuICAgIGNvbG9yOiBwcm9wcy50aGVtZS5jb2xvcnMuZ3JleVs3MF0sXG4gIH0pfVxuYDtcblxuZXhwb3J0IGNvbnN0IFRhYmxlRHJvcGRvd25JdGVtID0gc3R5bGVkLmRpdmBcbiAgcGFkZGluZzogNnB4IDEycHg7XG4gIHVzZXItc2VsZWN0OiBub25lO1xuICBjdXJzb3I6IHBvaW50ZXI7XG5cbiAgJHtwcm9wcyA9PiAoe1xuICAgIC4uLnByb3BzLnRoZW1lLnR5cG9ncmFwaHkucDFjb21wYWN0LFxuXG4gICAgY29sb3I6IHByb3BzLnRoZW1lLmNvbG9ycy5ncmV5WzEwMF0sXG4gIH0pfVxuXG4gIDpob3ZlciB7XG4gICAgYmFja2dyb3VuZC1jb2xvcjogJHtwcm9wcyA9PiBwcm9wcy50aGVtZS5jb2xvcnMuZ3JleVsxMF19O1xuICB9XG5cbiAgJltkYXRhLWNoZWNrZWRdIHtcbiAgICAke3Byb3BzID0+ICh7XG4gICAgICBjb2xvcjogcHJvcHMudGhlbWUuY29sb3JzLndoaXRlLFxuICAgICAgYmFja2dyb3VuZENvbG9yOiBwcm9wcy50aGVtZS5jb2xvcnMuYWNjZW50WzkwXSxcbiAgICB9KX1cbiAgfVxuYDtcbiJdfQ== */")), o = /* @__PURE__ */ b("div", process.env.NODE_ENV === "production" ? {
+  target: "enkh3l20"
+} : {
+  target: "enkh3l20",
+  label: "TableDropdownItem"
+})("padding:6px 12px;user-select:none;cursor:pointer;", (c) => ({
+  ...c.theme.typography.p1compact,
+  color: c.theme.colors.grey[100]
+}), " :hover{background-color:", (c) => c.theme.colors.grey[10], ";}&[data-checked]{", (c) => ({
+  color: c.theme.colors.white,
+  backgroundColor: c.theme.colors.accent[90]
+}), ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3NhZHlrb3ZzZC9qb2luLXg1L3BhY2thZ2VzL2RhdGEtZ3JpZC9zcmMvVGFibGVEcm9wZG93bi9pbmRleC50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBYTJDIiwiZmlsZSI6Ii9ob21lL3NhZHlrb3ZzZC9qb2luLXg1L3BhY2thZ2VzL2RhdGEtZ3JpZC9zcmMvVGFibGVEcm9wZG93bi9pbmRleC50c3giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBUYWJsZURyb3Bkb3duSGVhZGVyID0gc3R5bGVkLmRpdmBcbiAgcGFkZGluZzogOHB4IDEycHggNHB4O1xuICB1c2VyLXNlbGVjdDogbm9uZTtcblxuICAke3Byb3BzID0+ICh7XG4gICAgLi4ucHJvcHMudGhlbWUudHlwb2dyYXBoeS5oNixcblxuICAgIGNvbG9yOiBwcm9wcy50aGVtZS5jb2xvcnMuZ3JleVs3MF0sXG4gIH0pfVxuYDtcblxuZXhwb3J0IGNvbnN0IFRhYmxlRHJvcGRvd25JdGVtID0gc3R5bGVkLmRpdmBcbiAgcGFkZGluZzogNnB4IDEycHg7XG4gIHVzZXItc2VsZWN0OiBub25lO1xuICBjdXJzb3I6IHBvaW50ZXI7XG5cbiAgJHtwcm9wcyA9PiAoe1xuICAgIC4uLnByb3BzLnRoZW1lLnR5cG9ncmFwaHkucDFjb21wYWN0LFxuXG4gICAgY29sb3I6IHByb3BzLnRoZW1lLmNvbG9ycy5ncmV5WzEwMF0sXG4gIH0pfVxuXG4gIDpob3ZlciB7XG4gICAgYmFja2dyb3VuZC1jb2xvcjogJHtwcm9wcyA9PiBwcm9wcy50aGVtZS5jb2xvcnMuZ3JleVsxMF19O1xuICB9XG5cbiAgJltkYXRhLWNoZWNrZWRdIHtcbiAgICAke3Byb3BzID0+ICh7XG4gICAgICBjb2xvcjogcHJvcHMudGhlbWUuY29sb3JzLndoaXRlLFxuICAgICAgYmFja2dyb3VuZENvbG9yOiBwcm9wcy50aGVtZS5jb2xvcnMuYWNjZW50WzkwXSxcbiAgICB9KX1cbiAgfVxuYDtcbiJdfQ== */"));
+export {
+  g as TableDropdownHeader,
+  o as TableDropdownItem
+};
+//# sourceMappingURL=index.es.js.map

package/dist/TableDropdown/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../src/TableDropdown/index.tsx"],"sourcesContent":["import styled from '@emotion/styled';\n\nexport const TableDropdownHeader = styled.div`\n  padding: 8px 12px 4px;\n  user-select: none;\n\n  ${props => ({\n    ...props.theme.typography.h6,\n\n    color: props.theme.colors.grey[70],\n  })}\n`;\n\nexport const TableDropdownItem = styled.div`\n  padding: 6px 12px;\n  user-select: none;\n  cursor: pointer;\n\n  ${props => ({\n    ...props.theme.typography.p1compact,\n\n    color: props.theme.colors.grey[100],\n  })}\n\n  :hover {\n    background-color: ${props => props.theme.colors.grey[10]};\n  }\n\n  &[data-checked] {\n    ${props => ({\n      color: props.theme.colors.white,\n      backgroundColor: props.theme.colors.accent[90],\n    })}\n  }\n`;\n"],"names":["TableDropdownHeader","process","env","NODE_ENV","target","label","props","theme","typography","h6","color","colors","grey","TableDropdownItem","p1compact","white","backgroundColor","accent"],"mappings":";AAEO,MAAMA,6BAAmBC,QAAAC,IAAAC,aAAA,eAAA;AAAA,EAAAC,QAAA;AAAA,IAAA;AAAA,EAAAA,QAAA;AAAA,EAAAC,OAAA;AAAA,CAAA,EAAA,0CAI5BC,CAAUA,OAAA;AAAA,EACV,GAAGA,EAAMC,MAAMC,WAAWC;AAAAA,EAE1BC,OAAOJ,EAAMC,MAAMI,OAAOC,KAAK,EAAE;AACnC,IAAEX,OAAAA,QAAAC,IAAAC,aACH,eAAA,KAAA,0yCAAA,GAEYU,6BAAiBZ,QAAAC,IAAAC,aAAA,eAAA;AAAA,EAAAC,QAAA;AAAA,IAAA;AAAA,EAAAA,QAAA;AAAA,EAAAC,OAAA;AAAA,CAAA,EAAA,qDAK1BC,CAAUA,OAAA;AAAA,EACV,GAAGA,EAAMC,MAAMC,WAAWM;AAAAA,EAE1BJ,OAAOJ,EAAMC,MAAMI,OAAOC,KAAK,GAAG;AACpC,IAGsBN,6BAAAA,OAASA,EAAMC,MAAMI,OAAOC,KAAK,EAAE,GAAC,sBAItDN,CAAUA,OAAA;AAAA,EACVI,OAAOJ,EAAMC,MAAMI,OAAOI;AAAAA,EAC1BC,iBAAiBV,EAAMC,MAAMI,OAAOM,OAAO,EAAE;AAC/C,IAAEhB,QAAAA,QAAAC,IAAAC,aAEL,eAAA,KAAA,0yCAAA;"}

package/dist/TableHead/index.d.ts

@@ -0,0 +1,6 @@
+import { Table } from '@tanstack/react-table';
+export declare const TableHead: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, {}>;
+export declare const getDataGridTableHead: (table: Table<unknown>) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/TableHead/index.es.js

@@ -0,0 +1,31 @@
+"use client";
+import { jsx as b } from "@emotion/react/jsx-runtime";
+import n from "@emotion/styled/base";
+import { useContext as i } from "react";
+import { DataGridContext as o } from "../DataGridContext.es.js";
+import { getDataGridTableHeadCell as a } from "../TableHeadCell/index.es.js";
+import { TableHeadRow as l } from "../TableHeadRow/index.es.js";
+function Z() {
+  return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
+}
+const I = /* @__PURE__ */ n("thead", process.env.NODE_ENV === "production" ? {
+  target: "etxjaz80"
+} : {
+  target: "etxjaz80",
+  label: "TableHead"
+})(process.env.NODE_ENV === "production" ? {
+  name: "2hn84s",
+  styles: "position:sticky;top:0;z-index:2"
+} : {
+  name: "2hn84s",
+  styles: "position:sticky;top:0;z-index:2/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3NhZHlrb3ZzZC9qb2luLXg1L3BhY2thZ2VzL2RhdGEtZ3JpZC9zcmMvVGFibGVIZWFkL2luZGV4LnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXcUMiLCJmaWxlIjoiL2hvbWUvc2FkeWtvdnNkL2pvaW4teDUvcGFja2FnZXMvZGF0YS1ncmlkL3NyYy9UYWJsZUhlYWQvaW5kZXgudHN4Iiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBjbGllbnQnO1xuXG5pbXBvcnQge3VzZUNvbnRleHR9IGZyb20gJ3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuaW1wb3J0IHtEYXRhR3JpZENvbnRleHR9IGZyb20gJ0RhdGFHcmlkQ29udGV4dCc7XG5pbXBvcnQge2dldERhdGFHcmlkVGFibGVIZWFkQ2VsbH0gZnJvbSAnVGFibGVIZWFkQ2VsbCc7XG5pbXBvcnQge1RhYmxlSGVhZFJvd30gZnJvbSAnVGFibGVIZWFkUm93JztcblxuaW1wb3J0IHR5cGUge1RhYmxlfSBmcm9tICdAdGFuc3RhY2svcmVhY3QtdGFibGUnO1xuXG5leHBvcnQgY29uc3QgVGFibGVIZWFkID0gc3R5bGVkLnRoZWFkYFxuICBwb3NpdGlvbjogc3RpY2t5O1xuICB0b3A6IDA7XG4gIHotaW5kZXg6IDI7XG5gO1xuXG50eXBlIERhdGFHcmlkVGFibGVIZWFkUHJvcHMgPSB7XG4gIHRhYmxlOiBUYWJsZTx1bmtub3duPjtcbn07XG5cbmNvbnN0IERhdGFHcmlkVGFibGVIZWFkOiBSZWFjdC5GQzxEYXRhR3JpZFRhYmxlSGVhZFByb3BzPiA9IHByb3BzID0+IHtcbiAgY29uc3QgY29udGV4dCA9IHVzZUNvbnRleHQoRGF0YUdyaWRDb250ZXh0KTtcblxuICBjb25zdCBjb250ZW50ID0gcHJvcHMudGFibGVcbiAgICAuZ2V0SGVhZGVyR3JvdXBzKClcbiAgICAubWFwKGhlYWRlckdyb3VwID0+IChcbiAgICAgIDxUYWJsZUhlYWRSb3cga2V5PXtoZWFkZXJHcm91cC5pZH0+XG4gICAgICAgIHtoZWFkZXJHcm91cC5oZWFkZXJzLm1hcChoZWFkZXIgPT4gZ2V0RGF0YUdyaWRUYWJsZUhlYWRDZWxsKGhlYWRlcikpfVxuICAgICAgPC9UYWJsZUhlYWRSb3c+XG4gICAgKSk7XG5cbiAgcmV0dXJuIDxUYWJsZUhlYWQgZGF0YS1xYT17YCR7Y29udGV4dC5xYX0taGVhZGB9Pntjb250ZW50fTwvVGFibGVIZWFkPjtcbn07XG5cbmV4cG9ydCBjb25zdCBnZXREYXRhR3JpZFRhYmxlSGVhZCA9ICh0YWJsZTogVGFibGU8dW5rbm93bj4pID0+IHtcbiAgcmV0dXJuIDxEYXRhR3JpZFRhYmxlSGVhZCB0YWJsZT17dGFibGV9IC8+O1xufTtcbiJdfQ== */",
+  toString: Z
+}), s = (t) => {
+  const e = i(o), G = t.table.getHeaderGroups().map((c) => /* @__PURE__ */ b(l, { children: c.headers.map((d) => a(d)) }, c.id));
+  return /* @__PURE__ */ b(I, { "data-qa": `${e.qa}-head`, children: G });
+}, r = (t) => /* @__PURE__ */ b(s, { table: t });
+export {
+  I as TableHead,
+  r as getDataGridTableHead
+};
+//# sourceMappingURL=index.es.js.map

package/dist/TableHead/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../src/TableHead/index.tsx"],"sourcesContent":["'use client';\n\nimport {useContext} from 'react';\nimport styled from '@emotion/styled';\n\nimport {DataGridContext} from 'DataGridContext';\nimport {getDataGridTableHeadCell} from 'TableHeadCell';\nimport {TableHeadRow} from 'TableHeadRow';\n\nimport type {Table} from '@tanstack/react-table';\n\nexport const TableHead = styled.thead`\n  position: sticky;\n  top: 0;\n  z-index: 2;\n`;\n\ntype DataGridTableHeadProps = {\n  table: Table<unknown>;\n};\n\nconst DataGridTableHead: React.FC<DataGridTableHeadProps> = props => {\n  const context = useContext(DataGridContext);\n\n  const content = props.table\n    .getHeaderGroups()\n    .map(headerGroup => (\n      <TableHeadRow key={headerGroup.id}>\n        {headerGroup.headers.map(header => getDataGridTableHeadCell(header))}\n      </TableHeadRow>\n    ));\n\n  return <TableHead data-qa={`${context.qa}-head`}>{content}</TableHead>;\n};\n\nexport const getDataGridTableHead = (table: Table<unknown>) => {\n  return <DataGridTableHead table={table} />;\n};\n"],"names":["context"],"mappings":";;;;;;;AAAa;AAAA;AAAA;AAWN;AAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWdA;AAUN;AACF;;;;;"}

package/dist/TableHeadCell/index.d.ts

@@ -0,0 +1,14 @@
+import { Header } from '@tanstack/react-table';
+import { FRC } from '@join-x5/react-theme';
+import { TableHeadCellProps } from './types';
+export declare const TableHeadCellResizer: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableHeadCell: FRC<HTMLTableCellElement, TableHeadCellProps>;
+type DataGridTableHeadCellProps = {
+    header: Header<unknown, unknown>;
+};
+export declare const DataGridTableHeadCell: React.FC<DataGridTableHeadCellProps>;
+export declare const getDataGridTableHeadCell: (header: DataGridTableHeadCellProps["header"]) => import("@emotion/react/jsx-runtime").JSX.Element;
+export * from './types';