@amboss/design-system 4.0.6 → 4.1.0

package/build/esm/components/DataTable/TableBody.js

@@ -1 +1 @@
-import styled from"@emotion/styled";import React from"react";import{useResponsiveValue}from"../../shared/mediaQueries";import{LoadingSpinner}from"../LoadingSpinner/LoadingSpinner";import{EmptyState}from"../Patterns/EmptyState/EmptyState";import{DataTableDataRow}from"./internal/DataTableDataRow";import{DataTableRowGroup}from"./internal/DataTableRowGroup";import{getVisibleColumnCount}from"./internal/getVisibleColumnCount";import{resolveRowContext}from"./internal/resolveRowContext";let StyledEmptyTd=styled("td",{target:"e167a84a0",label:"StyledEmptyTd"})(({emptyTableContentHeight})=>({padding:0,...useResponsiveValue({height:emptyTableContentHeight})}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StickyEmptyContent=styled("div",{target:"e167a84a1",label:"StickyEmptyContent"})(({containerWidth})=>({position:"sticky",left:0,display:"flex",alignItems:"center",justifyContent:"center",height:"100%",width:containerWidth?`${containerWidth}px`:"100%"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");function EmptyTableBody({children,columns,emptyTableContentHeight,containerWidth}){return React.createElement("tbody",null,React.createElement("tr",null,React.createElement(StyledEmptyTd,{colSpan:getVisibleColumnCount(columns),emptyTableContentHeight:emptyTableContentHeight},React.createElement(StickyEmptyContent,{containerWidth:containerWidth},children))))}export default React.memo(function({className,columns,rows=[],bodyCellVerticalPadding,isTableScrolledToLeft,isTableScrolledToRight,isLoading,loadingStateScreenReaderText="Loading",isEmpty,emptyState,emptyTableContentHeight,containerWidth,footer,children,isFirstColumnSticky,isLastColumnSticky,emptyCellContent="--",selectedRowIds=[],onRowSelectionChange=()=>void 0,getRowProps}){if(isLoading){let bodyContent=children&&React.createElement(React.Fragment,null,children)||React.createElement(LoadingSpinner,{screenReaderText:loadingStateScreenReaderText});return React.createElement(EmptyTableBody,{columns:columns,emptyTableContentHeight:emptyTableContentHeight,containerWidth:containerWidth},bodyContent)}if(isEmpty){let body;return body=emptyState?React.createElement(EmptyState,{title:emptyState.title,description:emptyState.description,variant:emptyState.variant??"neutral",icon:emptyState.icon},emptyState.action):children?React.createElement(React.Fragment,null,children):React.createElement(EmptyState,{title:"No data",variant:"neutral"}),React.createElement(EmptyTableBody,{columns:columns,emptyTableContentHeight:emptyTableContentHeight,containerWidth:containerWidth},body)}let rowElements=rows.map((row,rowIndex)=>{let rowContext=resolveRowContext(row,{getRowProps,selectedRowIds}),isLastDataRow=rowIndex===rows.length-1;return React.createElement(DataTableRowGroup,{key:row.id},React.createElement(DataTableDataRow,{columns:columns,rowContext:rowContext,isLastDataRow:isLastDataRow,bodyCellVerticalPadding:bodyCellVerticalPadding,emptyCellContent:emptyCellContent,footer:footer,isFirstColumnSticky:isFirstColumnSticky,isLastColumnSticky:isLastColumnSticky,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,selectedRowIds:selectedRowIds,onRowSelectionChange:onRowSelectionChange}))});return React.createElement("tbody",{className:className},rowElements)});
+import styled from"@emotion/styled";import React from"react";import{useResponsiveValue}from"../../shared/mediaQueries";import{LoadingSpinner}from"../LoadingSpinner/LoadingSpinner";import{EmptyState}from"../Patterns/EmptyState/EmptyState";import{DataTableRowGroup}from"./internal/DataTableRowGroup";import{getVisibleColumnCount}from"./internal/getVisibleColumnCount";import{resolveRowContext}from"./internal/resolveRowContext";let StyledEmptyTd=styled("td",{target:"e1kp8voo0",label:"StyledEmptyTd"})(({emptyTableContentHeight})=>({padding:0,...useResponsiveValue({height:emptyTableContentHeight})}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/DataTable/TableBody.tsx","sources":["src/components/DataTable/TableBody.tsx"],"sourcesContent":["/* eslint-disable react/jsx-no-useless-fragment */\n\nimport styled from \"@emotion/styled\";\nimport React from \"react\";\nimport { useResponsiveValue } from \"../../shared/mediaQueries\";\nimport { LoadingSpinner } from \"../LoadingSpinner/LoadingSpinner\";\nimport { EmptyState } from \"../Patterns/EmptyState/EmptyState\";\nimport type { DataTableProps } from \"./DataTable\";\nimport type { DataTableRow, DataTableSlotProps } from \"./types\";\nimport { DataTableRowGroup } from \"./internal/DataTableRowGroup\";\nimport { getVisibleColumnCount } from \"./internal/getVisibleColumnCount\";\nimport type { InternalColumn } from \"./internal/types\";\nimport { resolveRowContext } from \"./internal/resolveRowContext\";\nimport type { TableCellProps } from \"./TableCell\";\n\nexport type TableBodyProps = {\n  className?: string;\n  columns: InternalColumn[];\n  /** Visible width (px) of the scroll container; empty/loading state\n   *  centers within it via sticky positioning. */\n  containerWidth?: number | null;\n  /** Props for the internal `EmptyState` rendered when `isEmpty` is true. */\n  emptyState?: DataTableSlotProps[\"emptyState\"];\n  expandedRowIds: DataTableRow[\"id\"][];\n  isTableExpandable?: boolean;\n  expandRowAriaLabel?: string;\n  collapseRowAriaLabel?: string;\n  onRowExpansionChange: (expandedRowIds: DataTableRow[\"id\"][]) => void;\n} & Pick<\n  DataTableProps,\n  | \"rows\"\n  | \"isLoading\"\n  | \"loadingStateScreenReaderText\"\n  | \"isEmpty\"\n  | \"emptyTableContentHeight\"\n  | \"bodyCellVerticalPadding\"\n  | \"footer\"\n  | \"isFirstColumnSticky\"\n  | \"isLastColumnSticky\"\n  | \"emptyCellContent\"\n  | \"selectedRowIds\"\n  | \"onRowSelectionChange\"\n  | \"getRowProps\"\n> &\n  Pick<TableCellProps, \"isTableScrolledToLeft\" | \"isTableScrolledToRight\">;\n\ntype EmptyTableBodyProps = Pick<\n  TableBodyProps,\n  \"columns\" | \"emptyTableContentHeight\" | \"containerWidth\"\n> & {\n  children: React.ReactElement;\n};\n\ntype StyledEmptyTdProps = Pick<EmptyTableBodyProps, \"emptyTableContentHeight\">;\n\nconst StyledEmptyTd = styled.td<StyledEmptyTdProps>(\n  ({ emptyTableContentHeight }) => ({\n    padding: 0,\n    ...useResponsiveValue({\n      height: emptyTableContentHeight,\n    }),\n  })\n);\n\nconst StickyEmptyContent = styled.div<{ containerWidth?: number | null }>(\n  ({ containerWidth }) => ({\n    position: \"sticky\",\n    left: 0,\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    height: \"100%\",\n    width: containerWidth ? `${containerWidth}px` : \"100%\",\n  })\n);\n\nfunction EmptyTableBody({\n  children,\n  columns,\n  emptyTableContentHeight,\n  containerWidth,\n}: EmptyTableBodyProps): React.ReactElement {\n  return (\n    <tbody>\n      <tr>\n        <StyledEmptyTd\n          colSpan={getVisibleColumnCount(columns)}\n          emptyTableContentHeight={emptyTableContentHeight}\n        >\n          <StickyEmptyContent containerWidth={containerWidth}>\n            {children}\n          </StickyEmptyContent>\n        </StyledEmptyTd>\n      </tr>\n    </tbody>\n  );\n}\n\nfunction TableBody({\n  className,\n  columns,\n  rows = [],\n  bodyCellVerticalPadding,\n  isTableScrolledToLeft,\n  isTableScrolledToRight,\n  isLoading,\n  loadingStateScreenReaderText = \"Loading\",\n  isEmpty,\n  emptyState,\n  emptyTableContentHeight,\n  containerWidth,\n  footer,\n  children,\n  isFirstColumnSticky,\n  isLastColumnSticky,\n  emptyCellContent = \"--\",\n  selectedRowIds = [],\n  onRowSelectionChange = () => undefined,\n  getRowProps,\n  expandedRowIds,\n  isTableExpandable = false,\n  expandRowAriaLabel,\n  collapseRowAriaLabel,\n  onRowExpansionChange,\n}: React.PropsWithChildren<TableBodyProps>): React.ReactElement {\n  if (isLoading) {\n    const customLoadingContent = children && <>{children}</>;\n    const bodyContent = customLoadingContent || (\n      <LoadingSpinner screenReaderText={loadingStateScreenReaderText} />\n    );\n\n    return (\n      <EmptyTableBody\n        columns={columns}\n        emptyTableContentHeight={emptyTableContentHeight}\n        containerWidth={containerWidth}\n      >\n        {bodyContent}\n      </EmptyTableBody>\n    );\n  }\n\n  if (isEmpty) {\n    let body: React.ReactElement;\n    if (emptyState) {\n      body = (\n        <EmptyState\n          title={emptyState.title}\n          description={emptyState.description}\n          variant={emptyState.variant ?? \"neutral\"}\n          icon={emptyState.icon}\n        >\n          {emptyState.action}\n        </EmptyState>\n      );\n    } else if (children) {\n      body = <>{children}</>;\n    } else {\n      body = <EmptyState title=\"No data\" variant=\"neutral\" />;\n    }\n\n    return (\n      <EmptyTableBody\n        columns={columns}\n        emptyTableContentHeight={emptyTableContentHeight}\n        containerWidth={containerWidth}\n      >\n        {body}\n      </EmptyTableBody>\n    );\n  }\n\n  const rowElements = rows.map((row, rowIndex) => {\n    const rowContext = resolveRowContext(row, {\n      getRowProps,\n      selectedRowIds,\n      expandedRowIds,\n      isTableExpandable,\n      expandRowAriaLabel,\n      collapseRowAriaLabel,\n    });\n    const isLastDataRow = rowIndex === rows.length - 1;\n\n    return (\n      <DataTableRowGroup\n        key={row.id}\n        columns={columns}\n        rowContext={rowContext}\n        isLastDataRow={isLastDataRow}\n        bodyCellVerticalPadding={bodyCellVerticalPadding}\n        emptyCellContent={emptyCellContent}\n        footer={footer}\n        isFirstColumnSticky={isFirstColumnSticky}\n        isLastColumnSticky={isLastColumnSticky}\n        isTableScrolledToLeft={isTableScrolledToLeft}\n        isTableScrolledToRight={isTableScrolledToRight}\n        selectedRowIds={selectedRowIds}\n        onRowSelectionChange={onRowSelectionChange}\n        onRowExpansionChange={onRowExpansionChange}\n      />\n    );\n  });\n\n  return <tbody className={className}>{rowElements}</tbody>;\n}\n\nexport default React.memo(TableBody);\n"],"names":[],"mappings":"AAuDsB"} */"),StickyEmptyContent=styled("div",{target:"e1kp8voo1",label:"StickyEmptyContent"})(({containerWidth})=>({position:"sticky",left:0,display:"flex",alignItems:"center",justifyContent:"center",height:"100%",width:containerWidth?`${containerWidth}px`:"100%"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/DataTable/TableBody.tsx","sources":["src/components/DataTable/TableBody.tsx"],"sourcesContent":["/* eslint-disable react/jsx-no-useless-fragment */\n\nimport styled from \"@emotion/styled\";\nimport React from \"react\";\nimport { useResponsiveValue } from \"../../shared/mediaQueries\";\nimport { LoadingSpinner } from \"../LoadingSpinner/LoadingSpinner\";\nimport { EmptyState } from \"../Patterns/EmptyState/EmptyState\";\nimport type { DataTableProps } from \"./DataTable\";\nimport type { DataTableRow, DataTableSlotProps } from \"./types\";\nimport { DataTableRowGroup } from \"./internal/DataTableRowGroup\";\nimport { getVisibleColumnCount } from \"./internal/getVisibleColumnCount\";\nimport type { InternalColumn } from \"./internal/types\";\nimport { resolveRowContext } from \"./internal/resolveRowContext\";\nimport type { TableCellProps } from \"./TableCell\";\n\nexport type TableBodyProps = {\n  className?: string;\n  columns: InternalColumn[];\n  /** Visible width (px) of the scroll container; empty/loading state\n   *  centers within it via sticky positioning. */\n  containerWidth?: number | null;\n  /** Props for the internal `EmptyState` rendered when `isEmpty` is true. */\n  emptyState?: DataTableSlotProps[\"emptyState\"];\n  expandedRowIds: DataTableRow[\"id\"][];\n  isTableExpandable?: boolean;\n  expandRowAriaLabel?: string;\n  collapseRowAriaLabel?: string;\n  onRowExpansionChange: (expandedRowIds: DataTableRow[\"id\"][]) => void;\n} & Pick<\n  DataTableProps,\n  | \"rows\"\n  | \"isLoading\"\n  | \"loadingStateScreenReaderText\"\n  | \"isEmpty\"\n  | \"emptyTableContentHeight\"\n  | \"bodyCellVerticalPadding\"\n  | \"footer\"\n  | \"isFirstColumnSticky\"\n  | \"isLastColumnSticky\"\n  | \"emptyCellContent\"\n  | \"selectedRowIds\"\n  | \"onRowSelectionChange\"\n  | \"getRowProps\"\n> &\n  Pick<TableCellProps, \"isTableScrolledToLeft\" | \"isTableScrolledToRight\">;\n\ntype EmptyTableBodyProps = Pick<\n  TableBodyProps,\n  \"columns\" | \"emptyTableContentHeight\" | \"containerWidth\"\n> & {\n  children: React.ReactElement;\n};\n\ntype StyledEmptyTdProps = Pick<EmptyTableBodyProps, \"emptyTableContentHeight\">;\n\nconst StyledEmptyTd = styled.td<StyledEmptyTdProps>(\n  ({ emptyTableContentHeight }) => ({\n    padding: 0,\n    ...useResponsiveValue({\n      height: emptyTableContentHeight,\n    }),\n  })\n);\n\nconst StickyEmptyContent = styled.div<{ containerWidth?: number | null }>(\n  ({ containerWidth }) => ({\n    position: \"sticky\",\n    left: 0,\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    height: \"100%\",\n    width: containerWidth ? `${containerWidth}px` : \"100%\",\n  })\n);\n\nfunction EmptyTableBody({\n  children,\n  columns,\n  emptyTableContentHeight,\n  containerWidth,\n}: EmptyTableBodyProps): React.ReactElement {\n  return (\n    <tbody>\n      <tr>\n        <StyledEmptyTd\n          colSpan={getVisibleColumnCount(columns)}\n          emptyTableContentHeight={emptyTableContentHeight}\n        >\n          <StickyEmptyContent containerWidth={containerWidth}>\n            {children}\n          </StickyEmptyContent>\n        </StyledEmptyTd>\n      </tr>\n    </tbody>\n  );\n}\n\nfunction TableBody({\n  className,\n  columns,\n  rows = [],\n  bodyCellVerticalPadding,\n  isTableScrolledToLeft,\n  isTableScrolledToRight,\n  isLoading,\n  loadingStateScreenReaderText = \"Loading\",\n  isEmpty,\n  emptyState,\n  emptyTableContentHeight,\n  containerWidth,\n  footer,\n  children,\n  isFirstColumnSticky,\n  isLastColumnSticky,\n  emptyCellContent = \"--\",\n  selectedRowIds = [],\n  onRowSelectionChange = () => undefined,\n  getRowProps,\n  expandedRowIds,\n  isTableExpandable = false,\n  expandRowAriaLabel,\n  collapseRowAriaLabel,\n  onRowExpansionChange,\n}: React.PropsWithChildren<TableBodyProps>): React.ReactElement {\n  if (isLoading) {\n    const customLoadingContent = children && <>{children}</>;\n    const bodyContent = customLoadingContent || (\n      <LoadingSpinner screenReaderText={loadingStateScreenReaderText} />\n    );\n\n    return (\n      <EmptyTableBody\n        columns={columns}\n        emptyTableContentHeight={emptyTableContentHeight}\n        containerWidth={containerWidth}\n      >\n        {bodyContent}\n      </EmptyTableBody>\n    );\n  }\n\n  if (isEmpty) {\n    let body: React.ReactElement;\n    if (emptyState) {\n      body = (\n        <EmptyState\n          title={emptyState.title}\n          description={emptyState.description}\n          variant={emptyState.variant ?? \"neutral\"}\n          icon={emptyState.icon}\n        >\n          {emptyState.action}\n        </EmptyState>\n      );\n    } else if (children) {\n      body = <>{children}</>;\n    } else {\n      body = <EmptyState title=\"No data\" variant=\"neutral\" />;\n    }\n\n    return (\n      <EmptyTableBody\n        columns={columns}\n        emptyTableContentHeight={emptyTableContentHeight}\n        containerWidth={containerWidth}\n      >\n        {body}\n      </EmptyTableBody>\n    );\n  }\n\n  const rowElements = rows.map((row, rowIndex) => {\n    const rowContext = resolveRowContext(row, {\n      getRowProps,\n      selectedRowIds,\n      expandedRowIds,\n      isTableExpandable,\n      expandRowAriaLabel,\n      collapseRowAriaLabel,\n    });\n    const isLastDataRow = rowIndex === rows.length - 1;\n\n    return (\n      <DataTableRowGroup\n        key={row.id}\n        columns={columns}\n        rowContext={rowContext}\n        isLastDataRow={isLastDataRow}\n        bodyCellVerticalPadding={bodyCellVerticalPadding}\n        emptyCellContent={emptyCellContent}\n        footer={footer}\n        isFirstColumnSticky={isFirstColumnSticky}\n        isLastColumnSticky={isLastColumnSticky}\n        isTableScrolledToLeft={isTableScrolledToLeft}\n        isTableScrolledToRight={isTableScrolledToRight}\n        selectedRowIds={selectedRowIds}\n        onRowSelectionChange={onRowSelectionChange}\n        onRowExpansionChange={onRowExpansionChange}\n      />\n    );\n  });\n\n  return <tbody className={className}>{rowElements}</tbody>;\n}\n\nexport default React.memo(TableBody);\n"],"names":[],"mappings":"AAgE2B"} */");function EmptyTableBody({children,columns,emptyTableContentHeight,containerWidth}){return React.createElement("tbody",null,React.createElement("tr",null,React.createElement(StyledEmptyTd,{colSpan:getVisibleColumnCount(columns),emptyTableContentHeight:emptyTableContentHeight},React.createElement(StickyEmptyContent,{containerWidth:containerWidth},children))))}export default React.memo(function({className,columns,rows=[],bodyCellVerticalPadding,isTableScrolledToLeft,isTableScrolledToRight,isLoading,loadingStateScreenReaderText="Loading",isEmpty,emptyState,emptyTableContentHeight,containerWidth,footer,children,isFirstColumnSticky,isLastColumnSticky,emptyCellContent="--",selectedRowIds=[],onRowSelectionChange=()=>void 0,getRowProps,expandedRowIds,isTableExpandable=!1,expandRowAriaLabel,collapseRowAriaLabel,onRowExpansionChange}){if(isLoading){let bodyContent=children&&React.createElement(React.Fragment,null,children)||React.createElement(LoadingSpinner,{screenReaderText:loadingStateScreenReaderText});return React.createElement(EmptyTableBody,{columns:columns,emptyTableContentHeight:emptyTableContentHeight,containerWidth:containerWidth},bodyContent)}if(isEmpty){let body;return body=emptyState?React.createElement(EmptyState,{title:emptyState.title,description:emptyState.description,variant:emptyState.variant??"neutral",icon:emptyState.icon},emptyState.action):children?React.createElement(React.Fragment,null,children):React.createElement(EmptyState,{title:"No data",variant:"neutral"}),React.createElement(EmptyTableBody,{columns:columns,emptyTableContentHeight:emptyTableContentHeight,containerWidth:containerWidth},body)}let rowElements=rows.map((row,rowIndex)=>{let rowContext=resolveRowContext(row,{getRowProps,selectedRowIds,expandedRowIds,isTableExpandable,expandRowAriaLabel,collapseRowAriaLabel}),isLastDataRow=rowIndex===rows.length-1;return React.createElement(DataTableRowGroup,{key:row.id,columns:columns,rowContext:rowContext,isLastDataRow:isLastDataRow,bodyCellVerticalPadding:bodyCellVerticalPadding,emptyCellContent:emptyCellContent,footer:footer,isFirstColumnSticky:isFirstColumnSticky,isLastColumnSticky:isLastColumnSticky,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,selectedRowIds:selectedRowIds,onRowSelectionChange:onRowSelectionChange,onRowExpansionChange:onRowExpansionChange})});return React.createElement("tbody",{className:className},rowElements)});

package/build/esm/components/DataTable/constants.d.ts

@@ -1,4 +1,19 @@
 export declare const CHECKBOX_COLUMN: {
+    /** @internal Control column identity for the row selection feature. */
     name: string;
+    /**
+     * Fixed width for the leading control cell (checkbox size s + horizontal
+     * cell padding). Kept in sync with EXPAND_COLUMN so both control columns align.
+     */
     width: string;
 };
+export declare const EXPAND_COLUMN: {
+    /** @internal Control column identity for the row expand feature. */
+    name: string;
+    /**
+     * Fixed width for the expand toggle cell (PictogramButton size xs + horizontal
+     * cell padding). Matches CHECKBOX_COLUMN so control columns stay aligned.
+     */
+    width: string;
+};
+export declare function getExpandedContentId(rowId: string): string;

package/build/esm/components/DataTable/constants.js

@@ -1 +1 @@
-export const CHECKBOX_COLUMN={name:"_checkboxColumn_",width:"48px"};
+export const CHECKBOX_COLUMN={name:"_checkboxColumn_",width:"48px"};export const EXPAND_COLUMN={name:"_expandColumn_",width:"48px"};export function getExpandedContentId(rowId){return`data-table-expanded-row-${rowId}`}

package/build/esm/components/DataTable/index.d.ts

@@ -4,3 +4,4 @@ export type { DataTableProps } from "./DataTable";
 export { useDataTableSort } from "./useDataTableSort";
 export { useDataTableQueryFilter } from "./useDataTableQueryFilter";
 export { useDataTableSelectRows } from "./useDataTableSelectRows";
+export { useDataTableExpandRows } from "./useDataTableExpandRows";

package/build/esm/components/DataTable/index.js

@@ -1 +1 @@
-export{DataTable,BaseDataTable}from"./DataTable";export{useDataTableSort}from"./useDataTableSort";export{useDataTableQueryFilter}from"./useDataTableQueryFilter";export{useDataTableSelectRows}from"./useDataTableSelectRows";
+export{DataTable,BaseDataTable}from"./DataTable";export{useDataTableSort}from"./useDataTableSort";export{useDataTableQueryFilter}from"./useDataTableQueryFilter";export{useDataTableSelectRows}from"./useDataTableSelectRows";export{useDataTableExpandRows}from"./useDataTableExpandRows";

package/build/esm/components/DataTable/internal/DataTableDataRow.d.ts

@@ -16,5 +16,6 @@ export type DataTableDataRowProps = {
     isTableScrolledToRight: boolean;
     selectedRowIds: DataTableRow["id"][];
     onRowSelectionChange: NonNullable<DataTableProps["onRowSelectionChange"]>;
+    onRowExpansionChange: (expandedRowIds: DataTableRow["id"][]) => void;
 };
-export declare function DataTableDataRow({ columns, rowContext, isLastDataRow, bodyCellVerticalPadding, emptyCellContent, footer, isFirstColumnSticky, isLastColumnSticky, isTableScrolledToLeft, isTableScrolledToRight, selectedRowIds, onRowSelectionChange, }: DataTableDataRowProps): React.ReactElement;
+export declare function DataTableDataRow({ columns, rowContext, isLastDataRow, bodyCellVerticalPadding, emptyCellContent, footer, isFirstColumnSticky, isLastColumnSticky, isTableScrolledToLeft, isTableScrolledToRight, selectedRowIds, onRowSelectionChange, onRowExpansionChange, }: DataTableDataRowProps): React.ReactElement;

package/build/esm/components/DataTable/internal/DataTableDataRow.js

@@ -1 +1 @@
-import React from"react";import{getColumnSticky}from"./getColumnSticky";import{StyledTd,StyledText,StyledTr}from"./tablePrimitives";import{isControlColumn}from"./types";export function DataTableDataRow({columns,rowContext,isLastDataRow,bodyCellVerticalPadding,emptyCellContent,footer,isFirstColumnSticky,isLastColumnSticky,isTableScrolledToLeft,isTableScrolledToRight,selectedRowIds,onRowSelectionChange}){let{row,rowProps,isSelected,verticalAlign,isActive}=rowContext,cellContext={row,rowProps,isSelected,selectedRowIds,onRowSelectionChange,emptyCellContent};return React.createElement(StyledTr,{footer:footer,verticalAlign:verticalAlign,isSelected:isSelected,isLastDataRow:isLastDataRow},columns.map((column,columnIndex)=>{let sticky=getColumnSticky({column,columnIndex,columns,isFirstColumnSticky,isLastColumnSticky});if(isControlColumn(column))return React.createElement(StyledTd,{key:column.name,alignColumn:"left",columnWidth:column.width,sticky:sticky,bodyCellVerticalPadding:bodyCellVerticalPadding,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,isActive:isActive,isSelected:isSelected},column.renderCell(cellContext));let{name,align="left",width,renderCell}=column,content=renderCell?renderCell(row):React.createElement(StyledText,{size:"s",alignColumn:align},row[name]?row[name]:emptyCellContent);return React.createElement(StyledTd,{key:name,alignColumn:align,columnWidth:width,sticky:sticky,bodyCellVerticalPadding:bodyCellVerticalPadding,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,isActive:isActive,isSelected:isSelected},content)}))}
+import React from"react";import{getColumnSticky}from"./getColumnSticky";import{StyledTd,StyledText,StyledTr}from"./tablePrimitives";import{isControlColumn}from"./types";export function DataTableDataRow({columns,rowContext,isLastDataRow,bodyCellVerticalPadding,emptyCellContent,footer,isFirstColumnSticky,isLastColumnSticky,isTableScrolledToLeft,isTableScrolledToRight,selectedRowIds,onRowSelectionChange,onRowExpansionChange}){let{row,rowProps,isSelected,isExpanded,expandedContentId,verticalAlign,isActive}=rowContext,cellContext={row,rowProps,isSelected,isExpanded,expandedContentId,selectedRowIds,onRowSelectionChange,onRowExpansionChange,emptyCellContent};return React.createElement(StyledTr,{footer:footer,verticalAlign:verticalAlign,isSelected:isSelected,isLastDataRow:isLastDataRow},columns.map((column,columnIndex)=>{let sticky=getColumnSticky({column,columnIndex,columns,isFirstColumnSticky,isLastColumnSticky});if(isControlColumn(column))return React.createElement(StyledTd,{key:column.name,alignColumn:"left",columnWidth:column.width,sticky:sticky,bodyCellVerticalPadding:bodyCellVerticalPadding,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,isActive:isActive,isSelected:isSelected},column.renderCell(cellContext));let{name,align="left",width,renderCell}=column,content=renderCell?renderCell(row):React.createElement(StyledText,{size:"s",alignColumn:align},row[name]?row[name]:emptyCellContent);return React.createElement(StyledTd,{key:name,alignColumn:align,columnWidth:width,sticky:sticky,bodyCellVerticalPadding:bodyCellVerticalPadding,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,isActive:isActive,isSelected:isSelected},content)}))}

package/build/esm/components/DataTable/internal/DataTableDetailRow.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { ReactNode } from "react";
+import type { DataTableProps } from "../DataTable";
+import type { InternalColumn } from "./types";
+export type DataTableDetailRowProps = {
+    columns: InternalColumn[];
+    contentId: string;
+    children: ReactNode;
+    bodyCellVerticalPadding?: DataTableProps["bodyCellVerticalPadding"];
+    isLastDataRow: boolean;
+    footer?: DataTableProps["footer"];
+};
+export declare function DataTableDetailRow({ columns, contentId, children, bodyCellVerticalPadding, isLastDataRow, footer, }: DataTableDetailRowProps): React.ReactElement;

package/build/esm/components/DataTable/internal/DataTableDetailRow.js

@@ -0,0 +1 @@
+import styled from"@emotion/styled";import React from"react";import{useResponsiveStyles}from"../../../shared/mediaQueries";import{getVisibleColumnCount}from"./getVisibleColumnCount";let StyledDetailTr=styled("tr",{target:"e1bs2gtz0",label:"StyledDetailTr"})(({theme})=>({td:{backgroundColor:theme.values.color.background.primary.default,borderBottom:`1px solid ${theme.values.color.divider.primary}`}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledDetailTd=styled("td",{target:"e1bs2gtz1",label:"StyledDetailTd"})(({theme,bodyCellVerticalPadding,hideBorderBottom})=>({...useResponsiveStyles({padding:[bodyCellVerticalPadding,{xxs:`${theme.variables.size.spacing.xxs} ${theme.variables.size.spacing.m}`,xs:`${theme.variables.size.spacing.xs} ${theme.variables.size.spacing.m}`,s:`${theme.variables.size.spacing.s} ${theme.variables.size.spacing.m}`,m:`${theme.variables.size.spacing.m} ${theme.variables.size.spacing.m}`,l:`${theme.variables.size.spacing.l} ${theme.variables.size.spacing.m}`}]}),...hideBorderBottom&&{borderBottom:"none"}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function DataTableDetailRow({columns,contentId,children,bodyCellVerticalPadding,isLastDataRow,footer}){return React.createElement(StyledDetailTr,null,React.createElement(StyledDetailTd,{id:contentId,colSpan:getVisibleColumnCount(columns),bodyCellVerticalPadding:bodyCellVerticalPadding,hideBorderBottom:!footer&&isLastDataRow},children))}

package/build/esm/components/DataTable/internal/DataTableRowGroup.d.ts

@@ -1,2 +1,21 @@
-import type { PropsWithChildren, ReactElement } from "react";
-export declare function DataTableRowGroup({ children, }: PropsWithChildren): ReactElement;
+import React from "react";
+import type { DataTableProps } from "../DataTable";
+import type { DataTableRow } from "../types";
+import type { ResolvedRowContext } from "./resolveRowContext";
+import type { InternalColumn } from "./types";
+export type DataTableRowGroupProps = {
+    columns: InternalColumn[];
+    rowContext: ResolvedRowContext;
+    isLastDataRow: boolean;
+    bodyCellVerticalPadding?: DataTableProps["bodyCellVerticalPadding"];
+    emptyCellContent: string;
+    footer?: DataTableProps["footer"];
+    isFirstColumnSticky?: boolean;
+    isLastColumnSticky?: boolean;
+    isTableScrolledToLeft: boolean;
+    isTableScrolledToRight: boolean;
+    selectedRowIds: DataTableRow["id"][];
+    onRowSelectionChange: NonNullable<DataTableProps["onRowSelectionChange"]>;
+    onRowExpansionChange: (expandedRowIds: DataTableRow["id"][]) => void;
+};
+export declare function DataTableRowGroup({ columns, rowContext, isLastDataRow, bodyCellVerticalPadding, emptyCellContent, footer, isFirstColumnSticky, isLastColumnSticky, isTableScrolledToLeft, isTableScrolledToRight, selectedRowIds, onRowSelectionChange, onRowExpansionChange, }: DataTableRowGroupProps): React.ReactElement;

package/build/esm/components/DataTable/internal/DataTableRowGroup.js

@@ -1 +1 @@
-import React from"react";export function DataTableRowGroup({children}){return React.Children.only(children)}
+import React from"react";import{DataTableDataRow}from"./DataTableDataRow";import{DataTableDetailRow}from"./DataTableDetailRow";export function DataTableRowGroup({columns,rowContext,isLastDataRow,bodyCellVerticalPadding,emptyCellContent,footer,isFirstColumnSticky,isLastColumnSticky,isTableScrolledToLeft,isTableScrolledToRight,selectedRowIds,onRowSelectionChange,onRowExpansionChange}){let{isExpanded,expandedContentId,rowProps}=rowContext,showDetail=isExpanded&&rowProps.isExpandable&&null!=rowProps.renderExpandedContent;return React.createElement(React.Fragment,null,React.createElement(DataTableDataRow,{columns:columns,rowContext:rowContext,isLastDataRow:isLastDataRow&&!showDetail,bodyCellVerticalPadding:bodyCellVerticalPadding,emptyCellContent:emptyCellContent,footer:footer,isFirstColumnSticky:isFirstColumnSticky,isLastColumnSticky:isLastColumnSticky,isTableScrolledToLeft:isTableScrolledToLeft,isTableScrolledToRight:isTableScrolledToRight,selectedRowIds:selectedRowIds,onRowSelectionChange:onRowSelectionChange,onRowExpansionChange:onRowExpansionChange}),showDetail&&React.createElement(DataTableDetailRow,{columns:columns,contentId:expandedContentId,bodyCellVerticalPadding:bodyCellVerticalPadding,isLastDataRow:isLastDataRow,footer:footer},rowProps.renderExpandedContent?.()))}

package/build/esm/components/DataTable/internal/buildInternalColumns.d.ts

@@ -2,8 +2,9 @@ import type { DataTableColumn } from "../types";
 import type { InternalColumn } from "./types";
 export type DataTableFeatures = {
     selectable?: boolean;
+    expandable?: boolean;
 };
-export declare function buildInternalColumns({ columns, features: { selectable }, }: {
+export declare function buildInternalColumns({ columns, features: { selectable, expandable }, }: {
     columns: DataTableColumn[];
     features: DataTableFeatures;
 }): InternalColumn[];

package/build/esm/components/DataTable/internal/buildInternalColumns.js

@@ -1 +1 @@
-import{createCheckboxColumn}from"./controlColumns/checkboxColumn";export function buildInternalColumns({columns,features:{selectable}}){let dataColumns=columns.map(column=>({...column,kind:"data"}));return selectable?[createCheckboxColumn(),...dataColumns]:dataColumns}
+import{createCheckboxColumn}from"./controlColumns/checkboxColumn";import{createExpandColumn}from"./controlColumns/expandColumn";export function buildInternalColumns({columns,features:{selectable,expandable}}){let dataColumns=columns.map(column=>({...column,kind:"data"})),controlColumns=[];return expandable&&controlColumns.push(createExpandColumn()),selectable&&controlColumns.push(createCheckboxColumn()),[...controlColumns,...dataColumns]}

package/build/esm/components/DataTable/internal/controlColumns/expandColumn.d.ts

@@ -0,0 +1,2 @@
+import type { ControlColumn } from "../types";
+export declare function createExpandColumn(): ControlColumn;

package/build/esm/components/DataTable/internal/controlColumns/expandColumn.js

@@ -0,0 +1 @@
+import React from"react";import{PictogramButton}from"../../../PictogramButton/PictogramButton";import{ScreenReaderText}from"../../../Utilities/ScreenReaderText/ScreenReaderText";import{EXPAND_COLUMN}from"../../constants";function ExpandBodyCell({row,rowProps,isExpanded,expandedContentId,onRowExpansionChange}){return rowProps.isExpandable&&rowProps.renderExpandedContent?React.createElement(PictogramButton,{size:"xs",icon:isExpanded?"chevron-down":"chevron-right","aria-label":isExpanded?rowProps.collapseRowAriaLabel:rowProps.expandRowAriaLabel,"aria-expanded":isExpanded,"aria-controls":isExpanded?expandedContentId:void 0,onClick:()=>{onRowExpansionChange(isExpanded?[]:[row.id])}}):null}export function createExpandColumn(){return{kind:"expand",name:EXPAND_COLUMN.name,width:EXPAND_COLUMN.width,renderHeader:()=>React.createElement(ScreenReaderText,null,"Expand"),renderCell:ctx=>React.createElement(ExpandBodyCell,{row:ctx.row,rowProps:ctx.rowProps,isExpanded:ctx.isExpanded,expandedContentId:ctx.expandedContentId,onRowExpansionChange:ctx.onRowExpansionChange})}}

package/build/esm/components/DataTable/internal/resolveRowContext.d.ts

@@ -1,3 +1,4 @@
+import type { ReactNode } from "react";
 import type { DataTableProps } from "../DataTable";
 import type { DataTableRow, DataTableRowProps } from "../types";
 export type ResolvedRowContext = {
@@ -6,12 +7,22 @@ export type ResolvedRowContext = {
         isActive: boolean;
         isSelectable: boolean;
         selectRowCheckboxAriaLabel: string;
+        isExpandable: boolean;
+        expandRowAriaLabel: string;
+        collapseRowAriaLabel: string;
+        renderExpandedContent?: () => ReactNode;
     };
     isSelected: boolean;
+    isExpanded: boolean;
+    expandedContentId: string;
     verticalAlign?: DataTableRowProps["verticalAlign"];
     isActive: boolean;
 };
-export declare function resolveRowContext(row: DataTableRow, { getRowProps, selectedRowIds, }: {
+export declare function resolveRowContext(row: DataTableRow, { getRowProps, selectedRowIds, expandedRowIds, isTableExpandable, expandRowAriaLabel: tableExpandRowAriaLabel, collapseRowAriaLabel: tableCollapseRowAriaLabel, }: {
     getRowProps?: DataTableProps["getRowProps"];
     selectedRowIds: DataTableRow["id"][];
+    expandedRowIds: DataTableRow["id"][];
+    isTableExpandable?: boolean;
+    expandRowAriaLabel?: string;
+    collapseRowAriaLabel?: string;
 }): ResolvedRowContext;

package/build/esm/components/DataTable/internal/resolveRowContext.js

@@ -1 +1 @@
-export function resolveRowContext(row,{getRowProps,selectedRowIds}){let rowProps=getRowProps?.(row)??{},{verticalAlign,isActive=!1,isSelectable=!0,selectRowCheckboxAriaLabel=`Select row ${row.id}`}=rowProps;return{row,rowProps:{...rowProps,isActive,isSelectable,selectRowCheckboxAriaLabel},isSelected:selectedRowIds.includes(row.id),verticalAlign,isActive}}
+import{getExpandedContentId}from"../constants";export function resolveRowContext(row,{getRowProps,selectedRowIds,expandedRowIds,isTableExpandable=!1,expandRowAriaLabel:tableExpandRowAriaLabel="Expand row",collapseRowAriaLabel:tableCollapseRowAriaLabel="Collapse row"}){let rowProps=getRowProps?.(row)??{},{verticalAlign,isActive=!1,isSelectable=!0,selectRowCheckboxAriaLabel=`Select row ${row.id}`,isExpandable=isTableExpandable,expandRowAriaLabel=tableExpandRowAriaLabel,collapseRowAriaLabel=tableCollapseRowAriaLabel,renderExpandedContent}=rowProps;return{row,rowProps:{...rowProps,isActive,isSelectable,selectRowCheckboxAriaLabel,isExpandable:isTableExpandable&&isExpandable,expandRowAriaLabel,collapseRowAriaLabel,renderExpandedContent},isSelected:selectedRowIds.includes(row.id),isExpanded:expandedRowIds.includes(row.id),expandedContentId:getExpandedContentId(row.id),verticalAlign,isActive}}

package/build/esm/components/DataTable/internal/types.d.ts

@@ -1,14 +1,17 @@
 import type { ReactNode } from "react";
 import type { DataTableProps } from "../DataTable";
 import type { DataTableColumn, DataTableRow, DataTableRowProps } from "../types";
-export type ControlColumnKind = "checkbox";
+export type ControlColumnKind = "checkbox" | "expand";
 export type HeaderRenderContext = Pick<DataTableProps, "onSort" | "currentlySortedByColumn" | "allRowsSelected" | "selectedRowIds" | "selectAllRowsCheckboxAriaLabel" | "onAllRowsSelectionChange">;
 export type RowCellRenderContext = {
     row: DataTableRow;
-    rowProps: Required<Pick<DataTableRowProps, "isSelectable" | "selectRowCheckboxAriaLabel">> & DataTableRowProps;
+    rowProps: Required<Pick<DataTableRowProps, "isSelectable" | "selectRowCheckboxAriaLabel" | "isExpandable" | "expandRowAriaLabel" | "collapseRowAriaLabel">> & DataTableRowProps;
     isSelected: boolean;
+    isExpanded: boolean;
+    expandedContentId: string;
     selectedRowIds: DataTableRow["id"][];
     onRowSelectionChange: NonNullable<DataTableProps["onRowSelectionChange"]>;
+    onRowExpansionChange: (expandedRowIds: DataTableRow["id"][]) => void;
     emptyCellContent: string;
 };
 export type DataColumn = DataTableColumn & {

package/build/esm/components/DataTable/types.d.ts

@@ -1,5 +1,5 @@
 import type { Property } from "csstype";
-import type { ReactElement } from "react";
+import type { ReactElement, ReactNode } from "react";
 import type { SlotProps } from "../../shared/slotProps";
 import type { TextAlignment, MQ } from "../../types";
 import type { EmptyStateProps } from "../Patterns/EmptyState/EmptyState";
@@ -31,6 +31,14 @@ export type DataTableRowProps = {
     isActive?: boolean;
     isSelectable?: boolean;
     selectRowCheckboxAriaLabel?: string;
+    /** When true, row renders an expand toggle. Defaults to true when the table is expandable. */
+    isExpandable?: boolean;
+    /** Content shown in the detail row when expanded. */
+    renderExpandedContent?: () => ReactNode;
+    /** Override table-level expand label for this row. */
+    expandRowAriaLabel?: string;
+    /** Override table-level collapse label for this row. */
+    collapseRowAriaLabel?: string;
 };
 export type DataTableSlotProps = SlotProps<{
     emptyState: Pick<EmptyStateProps, "title" | "description" | "variant" | "icon"> & {

package/build/esm/components/DataTable/useDataTableExpandRows.d.ts

@@ -0,0 +1,21 @@
+import type { Dispatch, SetStateAction } from "react";
+import type { DataTableProps } from "./DataTable";
+import type { DataTableRow } from "./types";
+type UseDataTableExpandRowsArgs = {
+    rows: DataTableProps["rows"];
+    getRowProps?: DataTableProps["getRowProps"];
+    initialExpandedRowIds?: DataTableRow["id"][];
+};
+type UseDataTableExpandRowsReturn = {
+    expandedRowIds: DataTableRow["id"][];
+    setExpandedRowIds: Dispatch<SetStateAction<DataTableRow["id"][]>>;
+    handleRowExpansionChange: NonNullable<DataTableProps["onRowExpansionChange"]>;
+};
+/**
+ * Convenience hook for controlled expandable DataTable state.
+ * Toggle UX expands one row at a time (`[]` or `[id]`); the API is an id array
+ * for consistency with `selectedRowIds`. When expanded ids leave the current
+ * `rows` set (e.g. pagination), they are filtered out of the returned value.
+ */
+export declare function useDataTableExpandRows({ rows, getRowProps, initialExpandedRowIds, }: UseDataTableExpandRowsArgs): UseDataTableExpandRowsReturn;
+export {};

package/build/esm/components/DataTable/useDataTableExpandRows.js

@@ -0,0 +1 @@
+import{useState}from"react";export function useDataTableExpandRows({rows=[],getRowProps=()=>({}),initialExpandedRowIds=[]}){let[expandedRowIds,setExpandedRowIds]=useState(initialExpandedRowIds),rowIdSet=new Set(rows.map(row=>row.id));return{expandedRowIds:expandedRowIds.filter(id=>rowIdSet.has(id)),setExpandedRowIds,handleRowExpansionChange:rowIds=>{setExpandedRowIds(rowIds.filter(rowId=>{let row=rows.find(item=>item.id===rowId);return!!row&&!1!==getRowProps(row).isExpandable}))}}}

package/build/esm/components/DataTable/useDataTableSelectRows.js

@@ -1 +1 @@
-import{useState}from"react";let defaultGetRowProps=()=>({isSelectable:!0});export function useDataTableSelectRows({rows,getRowProps=defaultGetRowProps,initialAllRowsSelected=!1,initialSelectedRowIds=[]}){let[allRowsSelected,setAllRowsSelected]=useState(initialAllRowsSelected),[selectedRowIds,setSelectedRowIds]=useState(initialSelectedRowIds);return{handleAllRowsSelectionChange:currentValue=>{currentValue?setSelectedRowIds(rows.filter(row=>getRowProps(row).isSelectable).map(({id})=>id)):setSelectedRowIds([]),setAllRowsSelected(currentValue)},handleRowSelectionChange:ids=>{let numOfSelectableRows=rows.filter(row=>getRowProps(row).isSelectable).length;ids.length===numOfSelectableRows?setAllRowsSelected(!0):setAllRowsSelected(!1),setSelectedRowIds(ids)},allRowsSelected,selectedRowIds,setAllRowsSelected,setSelectedRowIds}}
+import{useState}from"react";let defaultGetRowProps=()=>({isSelectable:!0});export function useDataTableSelectRows({rows,getRowProps=defaultGetRowProps,initialAllRowsSelected=!1,initialSelectedRowIds=[]}){let[allRowsSelected,setAllRowsSelected]=useState(initialAllRowsSelected),[selectedRowIds,setSelectedRowIds]=useState(initialSelectedRowIds);return{handleAllRowsSelectionChange:currentValue=>{currentValue?setSelectedRowIds(rows.filter(row=>!1!==getRowProps(row).isSelectable).map(({id})=>id)):setSelectedRowIds([]),setAllRowsSelected(currentValue)},handleRowSelectionChange:ids=>{let numOfSelectableRows=rows.filter(row=>!1!==getRowProps(row).isSelectable).length;ids.length===numOfSelectableRows?setAllRowsSelected(!0):setAllRowsSelected(!1),setSelectedRowIds(ids)},allRowsSelected,selectedRowIds,setAllRowsSelected,setSelectedRowIds}}

package/build/esm/components/Link/Link.js

@@ -1 +1 @@
-import React,{useContext,useMemo}from"react";import styled from"@emotion/styled";import isPropValid from"@emotion/is-prop-valid";import{TextContext}from"../Typography/Text/Text";import{LinkContext}from"./LinkContext";import{getLinkDecorationStyles}from"./getLinkDecorationStyles";import{Icon}from"../Icon/Icon";let StyledLink=styled("a",{shouldForwardProp:prop=>isPropValid(prop)&&"inline"!==prop,target:"e1wevig90",label:"StyledLink"})(({theme,weight,size,color,inline})=>({cursor:"pointer",background:"none",border:"none",padding:0,fontSize:theme.variables.size.font[size]??"inherit",fontWeight:theme.variables.weight[weight]??"inherit",lineHeight:({xs:theme.variables.size.lineHeight.xl,s:theme.variables.size.lineHeight.l,m:theme.variables.size.lineHeight.xl,l:theme.variables.size.lineHeight.xl})[size],fontFamily:theme.variables.fontFamily.lato,color:color?theme.values.color.text[color].default:"inherit",...getLinkDecorationStyles({theme,color,showsUnderline:!!inline,hoverSelector:"&:hover",includeHoverTextColor:!0}),"&[data-ds-id='Link']:has([data-ds-id='Text'], [data-ds-id='TextClamped'], [data-ds-id='ContentText'])":{"&, &:hover":{textDecorationLine:"none"}}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Link/Link.tsx","sources":["src/components/Link/Link.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React, { useContext, useMemo, type AriaAttributes } from \"react\";\nimport type { CSSObject } from \"@emotion/react\";\nimport styled from \"@emotion/styled\";\nimport isPropValid from \"@emotion/is-prop-valid\";\nimport { TextContext } from \"../Typography/Text/Text\";\nimport { LinkContext } from \"./LinkContext\";\nimport { getLinkDecorationStyles } from \"./getLinkDecorationStyles\";\nimport type { IconProps } from \"../Icon/Icon\";\nimport { Icon } from \"../Icon/Icon\";\nimport type {\n  TextColors,\n  TextSize,\n  TextWeight,\n  PolymorphicComponentPropsWithRef,\n  PolymorphicRef,\n  LinkVariations,\n} from \"../../types\";\n\ntype SupplementaryIconProps = Pick<IconProps, \"name\" | \"color\">;\n\nexport type LinkConditionalProps =\n  | {\n      /** It forces to inherit color, weight, size from parent */\n      inline: true;\n      /** A color is inherited from its parent Text otherwise set as 'primary' */\n      color: TextColors;\n      /** Icons are not supported for inline links */\n      iconLeft?: never;\n      /** Icons are not supported for inline links */\n      iconRight?: never;\n    }\n  | {\n      inline?: false | undefined;\n      color?: TextColors;\n      /** Icon displayed on the left side of the link */\n      iconLeft?: SupplementaryIconProps;\n      /** Icon displayed on the right side of the link */\n      iconRight?: SupplementaryIconProps;\n    };\n\nexport type LinkProps = {\n  /** A size is inherited from its parent */\n  size?: TextSize;\n  /** A weight is inherited from its parent */\n  weight?: TextWeight;\n  /** @deprecated variant, please use \"color\" prop instead */\n  variant?: LinkVariations;\n  \"data-e2e-test-id\"?: string;\n} & LinkConditionalProps &\n  AriaAttributes;\n\nexport type LinkComponent = <C extends React.ElementType = \"a\">(\n  props: PolymorphicComponentPropsWithRef<C, LinkProps>\n) => React.ReactNode | null;\n\n// A nested Text/TextClamped/ContentText paints its own underline in its resolved\n// color; matching one of these lets the anchor step back so the two underlines\n// don't compete (see the underline-suppression rule in StyledLink).\nconst NESTED_TEXT_SELECTOR =\n  \"[data-ds-id='Text'], [data-ds-id='TextClamped'], [data-ds-id='ContentText']\";\n\nconst StyledLink = styled(\"a\", {\n  shouldForwardProp: (prop) => isPropValid(prop) && prop !== \"inline\",\n})<Partial<LinkProps>>(\n  ({ theme, weight, size, color, inline }) =>\n    ({\n      cursor: \"pointer\",\n      background: \"none\",\n      border: \"none\",\n      padding: 0,\n      fontSize: theme.variables.size.font[size] ?? \"inherit\",\n      fontWeight: theme.variables.weight[weight] ?? \"inherit\",\n      lineHeight: {\n        xs: theme.variables.size.lineHeight.xl,\n        s: theme.variables.size.lineHeight.l,\n        m: theme.variables.size.lineHeight.xl,\n        l: theme.variables.size.lineHeight.xl,\n      }[size],\n      fontFamily: theme.variables.fontFamily.lato,\n\n      color: color ? theme.values.color.text[color].default : \"inherit\",\n\n      ...getLinkDecorationStyles({\n        theme,\n        color,\n        showsUnderline: !!inline,\n        hoverSelector: \"&:hover\",\n        includeHoverTextColor: true,\n      }),\n\n      // When a plain Link wraps a DS text component, that component paints the\n      // underline in its own resolved color. Suppress the anchor's own underline\n      // (resting and hover) so a differing nested color isn't overridden by the\n      // link's underline. Scoped to `data-ds-id='Link'` so ContentLink — which\n      // reuses this anchor but sets its own content-color underline and renders\n      // its own `data-ds-id` — keeps drawing its decoration.\n      [`&[data-ds-id='Link']:has(${NESTED_TEXT_SELECTOR})`]: {\n        \"&, &:hover\": {\n          textDecorationLine: \"none\",\n        },\n      },\n    } as CSSObject)\n);\n\nconst StyledIcon = styled(Icon)<{ position: \"left\" | \"right\" }>(\n  ({ position, theme }) => ({\n    ...(position === \"left\" && {\n      marginRight: theme.variables.size.spacing.xxs,\n    }),\n    ...(position === \"right\" && {\n      marginLeft: theme.variables.size.spacing.xxs,\n    }),\n  })\n);\n\nexport const Link: LinkComponent = React.forwardRef(\n  <C extends React.ElementType = \"a\">(\n    {\n      weight,\n      color: colorProp,\n      size,\n      variant,\n      inline,\n      iconLeft,\n      iconRight,\n      children,\n      \"data-e2e-test-id\": dataE2eTestId,\n      ...rest\n    }: PolymorphicComponentPropsWithRef<C, LinkProps>,\n    ref?: PolymorphicRef<C>\n  ) => {\n    const inheritPropsFromText = useContext(TextContext);\n\n    const getColor = () => {\n      if (variant) {\n        // this is going to be deleted after migration\n        if (variant === \"primary\") return \"accent\";\n        if (variant === \"secondary\") return \"primary\";\n        return variant;\n      }\n      if (colorProp) return colorProp;\n      if (inheritPropsFromText?.color) return inheritPropsFromText?.color;\n      if (!inline) return \"accent\";\n      return undefined;\n    };\n\n    const linkColor = getColor();\n\n    /* Why do we need inline prop? We inherit size and color from Text (if Link is wrapped in it), but we need to support Links within Headers and other custom components. Thus by default, size and color are not required props */\n    const isInlineLink = inline || !!inheritPropsFromText;\n\n    // Only a plain Link suppresses its own underline (see StyledLink); ContentLink\n    // renders its own data-ds-id and keeps drawing its content-color underline, so\n    // a nested text must not paint a competing one on top of it.\n    const dataDsId = (rest as { \"data-ds-id\"?: string })[\"data-ds-id\"];\n    const underlineOwnedByChild = (dataDsId ?? \"Link\") === \"Link\";\n\n    // Provide the link color and underline state to the context so a nested\n    // Text/TextClamped can inherit the link's resolved color when it doesn't set\n    // its own `color` prop, and re-draw the underline in its own color when it\n    // does. This keeps the glyph color and underline in sync with the anchor —\n    // notably under a SubThemeProvider, where a subtheme may override only some\n    // color tokens.\n    const linkContextValue = useMemo(\n      () =>\n        linkColor\n          ? {\n              color: linkColor,\n              showsUnderline: isInlineLink,\n              underlineOwnedByChild,\n            }\n          : null,\n      [linkColor, isInlineLink, underlineOwnedByChild]\n    );\n\n    const hasIcons = !isInlineLink && (iconLeft || iconRight);\n\n    const linkContent = hasIcons ? (\n      <>\n        {iconLeft && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconLeft.name}\n            color={iconLeft.color ?? linkColor}\n            inline\n            position=\"left\"\n          />\n        )}\n        {children}\n        {iconRight && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconRight.name}\n            color={iconRight.color ?? linkColor}\n            inline\n            position=\"right\"\n          />\n        )}\n      </>\n    ) : (\n      children\n    );\n\n    return (\n      <StyledLink\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Link\"\n        ref={ref}\n        inline={isInlineLink}\n        color={linkColor}\n        size={size || inheritPropsFromText?.size}\n        weight={weight || inheritPropsFromText?.weight}\n        {...rest}\n      >\n        <LinkContext.Provider value={linkContextValue}>\n          {linkContent}\n        </LinkContext.Provider>\n      </StyledLink>\n    );\n  }\n);\n"],"names":[],"mappings":"AA8DmB"} */"),StyledIcon=styled(Icon,{target:"e1wevig91",label:"StyledIcon"})(({position,theme})=>({..."left"===position&&{marginRight:theme.variables.size.spacing.xxs},..."right"===position&&{marginLeft:theme.variables.size.spacing.xxs}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Link/Link.tsx","sources":["src/components/Link/Link.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React, { useContext, useMemo, type AriaAttributes } from \"react\";\nimport type { CSSObject } from \"@emotion/react\";\nimport styled from \"@emotion/styled\";\nimport isPropValid from \"@emotion/is-prop-valid\";\nimport { TextContext } from \"../Typography/Text/Text\";\nimport { LinkContext } from \"./LinkContext\";\nimport { getLinkDecorationStyles } from \"./getLinkDecorationStyles\";\nimport type { IconProps } from \"../Icon/Icon\";\nimport { Icon } from \"../Icon/Icon\";\nimport type {\n  TextColors,\n  TextSize,\n  TextWeight,\n  PolymorphicComponentPropsWithRef,\n  PolymorphicRef,\n  LinkVariations,\n} from \"../../types\";\n\ntype SupplementaryIconProps = Pick<IconProps, \"name\" | \"color\">;\n\nexport type LinkConditionalProps =\n  | {\n      /** It forces to inherit color, weight, size from parent */\n      inline: true;\n      /** A color is inherited from its parent Text otherwise set as 'primary' */\n      color: TextColors;\n      /** Icons are not supported for inline links */\n      iconLeft?: never;\n      /** Icons are not supported for inline links */\n      iconRight?: never;\n    }\n  | {\n      inline?: false | undefined;\n      color?: TextColors;\n      /** Icon displayed on the left side of the link */\n      iconLeft?: SupplementaryIconProps;\n      /** Icon displayed on the right side of the link */\n      iconRight?: SupplementaryIconProps;\n    };\n\nexport type LinkProps = {\n  /** A size is inherited from its parent */\n  size?: TextSize;\n  /** A weight is inherited from its parent */\n  weight?: TextWeight;\n  /** @deprecated variant, please use \"color\" prop instead */\n  variant?: LinkVariations;\n  \"data-e2e-test-id\"?: string;\n} & LinkConditionalProps &\n  AriaAttributes;\n\nexport type LinkComponent = <C extends React.ElementType = \"a\">(\n  props: PolymorphicComponentPropsWithRef<C, LinkProps>\n) => React.ReactNode | null;\n\n// A nested Text/TextClamped/ContentText paints its own underline in its resolved\n// color; matching one of these lets the anchor step back so the two underlines\n// don't compete (see the underline-suppression rule in StyledLink).\nconst NESTED_TEXT_SELECTOR =\n  \"[data-ds-id='Text'], [data-ds-id='TextClamped'], [data-ds-id='ContentText']\";\n\nconst StyledLink = styled(\"a\", {\n  shouldForwardProp: (prop) => isPropValid(prop) && prop !== \"inline\",\n})<Partial<LinkProps>>(\n  ({ theme, weight, size, color, inline }) =>\n    ({\n      cursor: \"pointer\",\n      background: \"none\",\n      border: \"none\",\n      padding: 0,\n      fontSize: theme.variables.size.font[size] ?? \"inherit\",\n      fontWeight: theme.variables.weight[weight] ?? \"inherit\",\n      lineHeight: {\n        xs: theme.variables.size.lineHeight.xl,\n        s: theme.variables.size.lineHeight.l,\n        m: theme.variables.size.lineHeight.xl,\n        l: theme.variables.size.lineHeight.xl,\n      }[size],\n      fontFamily: theme.variables.fontFamily.lato,\n\n      color: color ? theme.values.color.text[color].default : \"inherit\",\n\n      ...getLinkDecorationStyles({\n        theme,\n        color,\n        showsUnderline: !!inline,\n        hoverSelector: \"&:hover\",\n        includeHoverTextColor: true,\n      }),\n\n      // When a plain Link wraps a DS text component, that component paints the\n      // underline in its own resolved color. Suppress the anchor's own underline\n      // (resting and hover) so a differing nested color isn't overridden by the\n      // link's underline. Scoped to `data-ds-id='Link'` so ContentLink — which\n      // reuses this anchor but sets its own content-color underline and renders\n      // its own `data-ds-id` — keeps drawing its decoration.\n      [`&[data-ds-id='Link']:has(${NESTED_TEXT_SELECTOR})`]: {\n        \"&, &:hover\": {\n          textDecorationLine: \"none\",\n        },\n      },\n    } as CSSObject)\n);\n\nconst StyledIcon = styled(Icon)<{ position: \"left\" | \"right\" }>(\n  ({ position, theme }) => ({\n    ...(position === \"left\" && {\n      marginRight: theme.variables.size.spacing.xxs,\n    }),\n    ...(position === \"right\" && {\n      marginLeft: theme.variables.size.spacing.xxs,\n    }),\n  })\n);\n\nexport const Link: LinkComponent = React.forwardRef(\n  <C extends React.ElementType = \"a\">(\n    {\n      weight,\n      color: colorProp,\n      size,\n      variant,\n      inline,\n      iconLeft,\n      iconRight,\n      children,\n      \"data-e2e-test-id\": dataE2eTestId,\n      ...rest\n    }: PolymorphicComponentPropsWithRef<C, LinkProps>,\n    ref?: PolymorphicRef<C>\n  ) => {\n    const inheritPropsFromText = useContext(TextContext);\n\n    const getColor = () => {\n      if (variant) {\n        // this is going to be deleted after migration\n        if (variant === \"primary\") return \"accent\";\n        if (variant === \"secondary\") return \"primary\";\n        return variant;\n      }\n      if (colorProp) return colorProp;\n      if (inheritPropsFromText?.color) return inheritPropsFromText?.color;\n      if (!inline) return \"accent\";\n      return undefined;\n    };\n\n    const linkColor = getColor();\n\n    /* Why do we need inline prop? We inherit size and color from Text (if Link is wrapped in it), but we need to support Links within Headers and other custom components. Thus by default, size and color are not required props */\n    const isInlineLink = inline || !!inheritPropsFromText;\n\n    // Only a plain Link suppresses its own underline (see StyledLink); ContentLink\n    // renders its own data-ds-id and keeps drawing its content-color underline, so\n    // a nested text must not paint a competing one on top of it.\n    const dataDsId = (rest as { \"data-ds-id\"?: string })[\"data-ds-id\"];\n    const underlineOwnedByChild = (dataDsId ?? \"Link\") === \"Link\";\n\n    // Provide the link color and underline state to the context so a nested\n    // Text/TextClamped can inherit the link's resolved color when it doesn't set\n    // its own `color` prop, and re-draw the underline in its own color when it\n    // does. This keeps the glyph color and underline in sync with the anchor —\n    // notably under a SubThemeProvider, where a subtheme may override only some\n    // color tokens.\n    const linkContextValue = useMemo(\n      () =>\n        linkColor\n          ? {\n              color: linkColor,\n              showsUnderline: isInlineLink,\n              underlineOwnedByChild,\n            }\n          : null,\n      [linkColor, isInlineLink, underlineOwnedByChild]\n    );\n\n    const hasIcons = !isInlineLink && (iconLeft || iconRight);\n\n    const linkContent = hasIcons ? (\n      <>\n        {iconLeft && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconLeft.name}\n            color={iconLeft.color ?? linkColor}\n            inline\n            position=\"left\"\n          />\n        )}\n        {children}\n        {iconRight && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconRight.name}\n            color={iconRight.color ?? linkColor}\n            inline\n            position=\"right\"\n          />\n        )}\n      </>\n    ) : (\n      children\n    );\n\n    return (\n      <StyledLink\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Link\"\n        ref={ref}\n        inline={isInlineLink}\n        color={linkColor}\n        size={size || inheritPropsFromText?.size}\n        weight={weight || inheritPropsFromText?.weight}\n        {...rest}\n      >\n        <LinkContext.Provider value={linkContextValue}>\n          {linkContent}\n        </LinkContext.Provider>\n      </StyledLink>\n    );\n  }\n);\n"],"names":[],"mappings":"AAyGmB"} */");export const Link=React.forwardRef(({weight,color:colorProp,size,variant,inline,iconLeft,iconRight,children,"data-e2e-test-id":dataE2eTestId,...rest},ref)=>{let inheritPropsFromText=useContext(TextContext),linkColor=variant?"primary"===variant?"accent":"secondary"===variant?"primary":variant:colorProp||(inheritPropsFromText?.color?inheritPropsFromText?.color:inline?void 0:"accent"),isInlineLink=inline||!!inheritPropsFromText,underlineOwnedByChild=(rest["data-ds-id"]??"Link")==="Link",linkContextValue=useMemo(()=>linkColor?{color:linkColor,showsUnderline:isInlineLink,underlineOwnedByChild}:null,[linkColor,isInlineLink,underlineOwnedByChild]),linkContent=!isInlineLink&&(iconLeft||iconRight)?React.createElement(React.Fragment,null,iconLeft&&React.createElement(StyledIcon,{"aria-hidden":!0,size:"s",name:iconLeft.name,color:iconLeft.color??linkColor,inline:!0,position:"left"}),children,iconRight&&React.createElement(StyledIcon,{"aria-hidden":!0,size:"s",name:iconRight.name,color:iconRight.color??linkColor,inline:!0,position:"right"})):children;return React.createElement(StyledLink,{"data-e2e-test-id":dataE2eTestId,"data-ds-id":"Link",ref:ref,inline:isInlineLink,color:linkColor,size:size||inheritPropsFromText?.size,weight:weight||inheritPropsFromText?.weight,...rest},React.createElement(LinkContext.Provider,{value:linkContextValue},linkContent))});
+import React,{useContext,useMemo}from"react";import styled from"@emotion/styled";import isPropValid from"@emotion/is-prop-valid";import{TextContext}from"../Typography/Text/Text";import{LinkContext}from"./LinkContext";import{getLinkDecorationStyles}from"./getLinkDecorationStyles";import{Icon}from"../Icon/Icon";let nestedTextSuppressionSelector=["Text","TextClamped","ContentText"].map(id=>`&[data-ds-id='Link']:has([data-ds-id='${id}'])`).join(", "),StyledLink=styled("a",{shouldForwardProp:prop=>isPropValid(prop)&&"inline"!==prop,target:"e1khz5hq0",label:"StyledLink"})(({theme,weight,size,color,inline})=>({cursor:"pointer",background:"none",border:"none",padding:0,fontSize:theme.variables.size.font[size]??"inherit",fontWeight:theme.variables.weight[weight]??"inherit",lineHeight:({xs:theme.variables.size.lineHeight.xl,s:theme.variables.size.lineHeight.l,m:theme.variables.size.lineHeight.xl,l:theme.variables.size.lineHeight.xl})[size],fontFamily:theme.variables.fontFamily.lato,color:color?theme.values.color.text[color].default:"inherit",...getLinkDecorationStyles({theme,color,showsUnderline:!!inline,hoverSelector:"&:hover",includeHoverTextColor:!0}),[nestedTextSuppressionSelector]:{"&, &:hover":{textDecorationLine:"none"}}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Link/Link.tsx","sources":["src/components/Link/Link.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React, { useContext, useMemo, type AriaAttributes } from \"react\";\nimport type { CSSObject } from \"@emotion/react\";\nimport styled from \"@emotion/styled\";\nimport isPropValid from \"@emotion/is-prop-valid\";\nimport { TextContext } from \"../Typography/Text/Text\";\nimport { LinkContext } from \"./LinkContext\";\nimport { getLinkDecorationStyles } from \"./getLinkDecorationStyles\";\nimport type { IconProps } from \"../Icon/Icon\";\nimport { Icon } from \"../Icon/Icon\";\nimport type {\n  TextColors,\n  TextSize,\n  TextWeight,\n  PolymorphicComponentPropsWithRef,\n  PolymorphicRef,\n  LinkVariations,\n} from \"../../types\";\n\ntype SupplementaryIconProps = Pick<IconProps, \"name\" | \"color\">;\n\nexport type LinkConditionalProps =\n  | {\n      /** It forces to inherit color, weight, size from parent */\n      inline: true;\n      /** A color is inherited from its parent Text otherwise set as 'primary' */\n      color: TextColors;\n      /** Icons are not supported for inline links */\n      iconLeft?: never;\n      /** Icons are not supported for inline links */\n      iconRight?: never;\n    }\n  | {\n      inline?: false | undefined;\n      color?: TextColors;\n      /** Icon displayed on the left side of the link */\n      iconLeft?: SupplementaryIconProps;\n      /** Icon displayed on the right side of the link */\n      iconRight?: SupplementaryIconProps;\n    };\n\nexport type LinkProps = {\n  /** A size is inherited from its parent */\n  size?: TextSize;\n  /** A weight is inherited from its parent */\n  weight?: TextWeight;\n  /** @deprecated variant, please use \"color\" prop instead */\n  variant?: LinkVariations;\n  \"data-e2e-test-id\"?: string;\n} & LinkConditionalProps &\n  AriaAttributes;\n\nexport type LinkComponent = <C extends React.ElementType = \"a\">(\n  props: PolymorphicComponentPropsWithRef<C, LinkProps>\n) => React.ReactNode | null;\n\n// A nested Text/TextClamped/ContentText paints its own underline in its resolved\n// color; matching one of these lets the anchor step back so the two underlines\n// don't compete (see the underline-suppression rule in StyledLink).\nconst NESTED_TEXT_DS_IDS = [\"Text\", \"TextClamped\", \"ContentText\"];\n\n// One single-arg `:has()` per id, not one `:has()` with a selector list: the\n// list form is valid CSS but jsdom's nwsapi parser rejects it, breaking\n// `getComputedStyle` in consumers' jsdom tests.\nconst nestedTextSuppressionSelector = NESTED_TEXT_DS_IDS.map(\n  (id) => `&[data-ds-id='Link']:has([data-ds-id='${id}'])`\n).join(\", \");\n\nconst StyledLink = styled(\"a\", {\n  shouldForwardProp: (prop) => isPropValid(prop) && prop !== \"inline\",\n})<Partial<LinkProps>>(\n  ({ theme, weight, size, color, inline }) =>\n    ({\n      cursor: \"pointer\",\n      background: \"none\",\n      border: \"none\",\n      padding: 0,\n      fontSize: theme.variables.size.font[size] ?? \"inherit\",\n      fontWeight: theme.variables.weight[weight] ?? \"inherit\",\n      lineHeight: {\n        xs: theme.variables.size.lineHeight.xl,\n        s: theme.variables.size.lineHeight.l,\n        m: theme.variables.size.lineHeight.xl,\n        l: theme.variables.size.lineHeight.xl,\n      }[size],\n      fontFamily: theme.variables.fontFamily.lato,\n\n      color: color ? theme.values.color.text[color].default : \"inherit\",\n\n      ...getLinkDecorationStyles({\n        theme,\n        color,\n        showsUnderline: !!inline,\n        hoverSelector: \"&:hover\",\n        includeHoverTextColor: true,\n      }),\n\n      // When a plain Link wraps a DS text component, that component paints the\n      // underline in its own resolved color. Suppress the anchor's own underline\n      // (resting and hover) so a differing nested color isn't overridden by the\n      // link's underline. Scoped to `data-ds-id='Link'` so ContentLink — which\n      // reuses this anchor but sets its own content-color underline and renders\n      // its own `data-ds-id` — keeps drawing its decoration.\n      [nestedTextSuppressionSelector]: {\n        \"&, &:hover\": {\n          textDecorationLine: \"none\",\n        },\n      },\n    } as CSSObject)\n);\n\nconst StyledIcon = styled(Icon)<{ position: \"left\" | \"right\" }>(\n  ({ position, theme }) => ({\n    ...(position === \"left\" && {\n      marginRight: theme.variables.size.spacing.xxs,\n    }),\n    ...(position === \"right\" && {\n      marginLeft: theme.variables.size.spacing.xxs,\n    }),\n  })\n);\n\nexport const Link: LinkComponent = React.forwardRef(\n  <C extends React.ElementType = \"a\">(\n    {\n      weight,\n      color: colorProp,\n      size,\n      variant,\n      inline,\n      iconLeft,\n      iconRight,\n      children,\n      \"data-e2e-test-id\": dataE2eTestId,\n      ...rest\n    }: PolymorphicComponentPropsWithRef<C, LinkProps>,\n    ref?: PolymorphicRef<C>\n  ) => {\n    const inheritPropsFromText = useContext(TextContext);\n\n    const getColor = () => {\n      if (variant) {\n        // this is going to be deleted after migration\n        if (variant === \"primary\") return \"accent\";\n        if (variant === \"secondary\") return \"primary\";\n        return variant;\n      }\n      if (colorProp) return colorProp;\n      if (inheritPropsFromText?.color) return inheritPropsFromText?.color;\n      if (!inline) return \"accent\";\n      return undefined;\n    };\n\n    const linkColor = getColor();\n\n    /* Why do we need inline prop? We inherit size and color from Text (if Link is wrapped in it), but we need to support Links within Headers and other custom components. Thus by default, size and color are not required props */\n    const isInlineLink = inline || !!inheritPropsFromText;\n\n    // Only a plain Link suppresses its own underline (see StyledLink); ContentLink\n    // renders its own data-ds-id and keeps drawing its content-color underline, so\n    // a nested text must not paint a competing one on top of it.\n    const dataDsId = (rest as { \"data-ds-id\"?: string })[\"data-ds-id\"];\n    const underlineOwnedByChild = (dataDsId ?? \"Link\") === \"Link\";\n\n    // Provide the link color and underline state to the context so a nested\n    // Text/TextClamped can inherit the link's resolved color when it doesn't set\n    // its own `color` prop, and re-draw the underline in its own color when it\n    // does. This keeps the glyph color and underline in sync with the anchor —\n    // notably under a SubThemeProvider, where a subtheme may override only some\n    // color tokens.\n    const linkContextValue = useMemo(\n      () =>\n        linkColor\n          ? {\n              color: linkColor,\n              showsUnderline: isInlineLink,\n              underlineOwnedByChild,\n            }\n          : null,\n      [linkColor, isInlineLink, underlineOwnedByChild]\n    );\n\n    const hasIcons = !isInlineLink && (iconLeft || iconRight);\n\n    const linkContent = hasIcons ? (\n      <>\n        {iconLeft && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconLeft.name}\n            color={iconLeft.color ?? linkColor}\n            inline\n            position=\"left\"\n          />\n        )}\n        {children}\n        {iconRight && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconRight.name}\n            color={iconRight.color ?? linkColor}\n            inline\n            position=\"right\"\n          />\n        )}\n      </>\n    ) : (\n      children\n    );\n\n    return (\n      <StyledLink\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Link\"\n        ref={ref}\n        inline={isInlineLink}\n        color={linkColor}\n        size={size || inheritPropsFromText?.size}\n        weight={weight || inheritPropsFromText?.weight}\n        {...rest}\n      >\n        <LinkContext.Provider value={linkContextValue}>\n          {linkContent}\n        </LinkContext.Provider>\n      </StyledLink>\n    );\n  }\n);\n"],"names":[],"mappings":"AAoEmB"} */"),StyledIcon=styled(Icon,{target:"e1khz5hq1",label:"StyledIcon"})(({position,theme})=>({..."left"===position&&{marginRight:theme.variables.size.spacing.xxs},..."right"===position&&{marginLeft:theme.variables.size.spacing.xxs}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Link/Link.tsx","sources":["src/components/Link/Link.tsx"],"sourcesContent":["/* eslint-disable react/jsx-props-no-spreading */\nimport React, { useContext, useMemo, type AriaAttributes } from \"react\";\nimport type { CSSObject } from \"@emotion/react\";\nimport styled from \"@emotion/styled\";\nimport isPropValid from \"@emotion/is-prop-valid\";\nimport { TextContext } from \"../Typography/Text/Text\";\nimport { LinkContext } from \"./LinkContext\";\nimport { getLinkDecorationStyles } from \"./getLinkDecorationStyles\";\nimport type { IconProps } from \"../Icon/Icon\";\nimport { Icon } from \"../Icon/Icon\";\nimport type {\n  TextColors,\n  TextSize,\n  TextWeight,\n  PolymorphicComponentPropsWithRef,\n  PolymorphicRef,\n  LinkVariations,\n} from \"../../types\";\n\ntype SupplementaryIconProps = Pick<IconProps, \"name\" | \"color\">;\n\nexport type LinkConditionalProps =\n  | {\n      /** It forces to inherit color, weight, size from parent */\n      inline: true;\n      /** A color is inherited from its parent Text otherwise set as 'primary' */\n      color: TextColors;\n      /** Icons are not supported for inline links */\n      iconLeft?: never;\n      /** Icons are not supported for inline links */\n      iconRight?: never;\n    }\n  | {\n      inline?: false | undefined;\n      color?: TextColors;\n      /** Icon displayed on the left side of the link */\n      iconLeft?: SupplementaryIconProps;\n      /** Icon displayed on the right side of the link */\n      iconRight?: SupplementaryIconProps;\n    };\n\nexport type LinkProps = {\n  /** A size is inherited from its parent */\n  size?: TextSize;\n  /** A weight is inherited from its parent */\n  weight?: TextWeight;\n  /** @deprecated variant, please use \"color\" prop instead */\n  variant?: LinkVariations;\n  \"data-e2e-test-id\"?: string;\n} & LinkConditionalProps &\n  AriaAttributes;\n\nexport type LinkComponent = <C extends React.ElementType = \"a\">(\n  props: PolymorphicComponentPropsWithRef<C, LinkProps>\n) => React.ReactNode | null;\n\n// A nested Text/TextClamped/ContentText paints its own underline in its resolved\n// color; matching one of these lets the anchor step back so the two underlines\n// don't compete (see the underline-suppression rule in StyledLink).\nconst NESTED_TEXT_DS_IDS = [\"Text\", \"TextClamped\", \"ContentText\"];\n\n// One single-arg `:has()` per id, not one `:has()` with a selector list: the\n// list form is valid CSS but jsdom's nwsapi parser rejects it, breaking\n// `getComputedStyle` in consumers' jsdom tests.\nconst nestedTextSuppressionSelector = NESTED_TEXT_DS_IDS.map(\n  (id) => `&[data-ds-id='Link']:has([data-ds-id='${id}'])`\n).join(\", \");\n\nconst StyledLink = styled(\"a\", {\n  shouldForwardProp: (prop) => isPropValid(prop) && prop !== \"inline\",\n})<Partial<LinkProps>>(\n  ({ theme, weight, size, color, inline }) =>\n    ({\n      cursor: \"pointer\",\n      background: \"none\",\n      border: \"none\",\n      padding: 0,\n      fontSize: theme.variables.size.font[size] ?? \"inherit\",\n      fontWeight: theme.variables.weight[weight] ?? \"inherit\",\n      lineHeight: {\n        xs: theme.variables.size.lineHeight.xl,\n        s: theme.variables.size.lineHeight.l,\n        m: theme.variables.size.lineHeight.xl,\n        l: theme.variables.size.lineHeight.xl,\n      }[size],\n      fontFamily: theme.variables.fontFamily.lato,\n\n      color: color ? theme.values.color.text[color].default : \"inherit\",\n\n      ...getLinkDecorationStyles({\n        theme,\n        color,\n        showsUnderline: !!inline,\n        hoverSelector: \"&:hover\",\n        includeHoverTextColor: true,\n      }),\n\n      // When a plain Link wraps a DS text component, that component paints the\n      // underline in its own resolved color. Suppress the anchor's own underline\n      // (resting and hover) so a differing nested color isn't overridden by the\n      // link's underline. Scoped to `data-ds-id='Link'` so ContentLink — which\n      // reuses this anchor but sets its own content-color underline and renders\n      // its own `data-ds-id` — keeps drawing its decoration.\n      [nestedTextSuppressionSelector]: {\n        \"&, &:hover\": {\n          textDecorationLine: \"none\",\n        },\n      },\n    } as CSSObject)\n);\n\nconst StyledIcon = styled(Icon)<{ position: \"left\" | \"right\" }>(\n  ({ position, theme }) => ({\n    ...(position === \"left\" && {\n      marginRight: theme.variables.size.spacing.xxs,\n    }),\n    ...(position === \"right\" && {\n      marginLeft: theme.variables.size.spacing.xxs,\n    }),\n  })\n);\n\nexport const Link: LinkComponent = React.forwardRef(\n  <C extends React.ElementType = \"a\">(\n    {\n      weight,\n      color: colorProp,\n      size,\n      variant,\n      inline,\n      iconLeft,\n      iconRight,\n      children,\n      \"data-e2e-test-id\": dataE2eTestId,\n      ...rest\n    }: PolymorphicComponentPropsWithRef<C, LinkProps>,\n    ref?: PolymorphicRef<C>\n  ) => {\n    const inheritPropsFromText = useContext(TextContext);\n\n    const getColor = () => {\n      if (variant) {\n        // this is going to be deleted after migration\n        if (variant === \"primary\") return \"accent\";\n        if (variant === \"secondary\") return \"primary\";\n        return variant;\n      }\n      if (colorProp) return colorProp;\n      if (inheritPropsFromText?.color) return inheritPropsFromText?.color;\n      if (!inline) return \"accent\";\n      return undefined;\n    };\n\n    const linkColor = getColor();\n\n    /* Why do we need inline prop? We inherit size and color from Text (if Link is wrapped in it), but we need to support Links within Headers and other custom components. Thus by default, size and color are not required props */\n    const isInlineLink = inline || !!inheritPropsFromText;\n\n    // Only a plain Link suppresses its own underline (see StyledLink); ContentLink\n    // renders its own data-ds-id and keeps drawing its content-color underline, so\n    // a nested text must not paint a competing one on top of it.\n    const dataDsId = (rest as { \"data-ds-id\"?: string })[\"data-ds-id\"];\n    const underlineOwnedByChild = (dataDsId ?? \"Link\") === \"Link\";\n\n    // Provide the link color and underline state to the context so a nested\n    // Text/TextClamped can inherit the link's resolved color when it doesn't set\n    // its own `color` prop, and re-draw the underline in its own color when it\n    // does. This keeps the glyph color and underline in sync with the anchor —\n    // notably under a SubThemeProvider, where a subtheme may override only some\n    // color tokens.\n    const linkContextValue = useMemo(\n      () =>\n        linkColor\n          ? {\n              color: linkColor,\n              showsUnderline: isInlineLink,\n              underlineOwnedByChild,\n            }\n          : null,\n      [linkColor, isInlineLink, underlineOwnedByChild]\n    );\n\n    const hasIcons = !isInlineLink && (iconLeft || iconRight);\n\n    const linkContent = hasIcons ? (\n      <>\n        {iconLeft && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconLeft.name}\n            color={iconLeft.color ?? linkColor}\n            inline\n            position=\"left\"\n          />\n        )}\n        {children}\n        {iconRight && (\n          <StyledIcon\n            aria-hidden\n            size=\"s\"\n            name={iconRight.name}\n            color={iconRight.color ?? linkColor}\n            inline\n            position=\"right\"\n          />\n        )}\n      </>\n    ) : (\n      children\n    );\n\n    return (\n      <StyledLink\n        data-e2e-test-id={dataE2eTestId}\n        data-ds-id=\"Link\"\n        ref={ref}\n        inline={isInlineLink}\n        color={linkColor}\n        size={size || inheritPropsFromText?.size}\n        weight={weight || inheritPropsFromText?.weight}\n        {...rest}\n      >\n        <LinkContext.Provider value={linkContextValue}>\n          {linkContent}\n        </LinkContext.Provider>\n      </StyledLink>\n    );\n  }\n);\n"],"names":[],"mappings":"AA+GmB"} */");export const Link=React.forwardRef(({weight,color:colorProp,size,variant,inline,iconLeft,iconRight,children,"data-e2e-test-id":dataE2eTestId,...rest},ref)=>{let inheritPropsFromText=useContext(TextContext),linkColor=variant?"primary"===variant?"accent":"secondary"===variant?"primary":variant:colorProp||(inheritPropsFromText?.color?inheritPropsFromText?.color:inline?void 0:"accent"),isInlineLink=inline||!!inheritPropsFromText,underlineOwnedByChild=(rest["data-ds-id"]??"Link")==="Link",linkContextValue=useMemo(()=>linkColor?{color:linkColor,showsUnderline:isInlineLink,underlineOwnedByChild}:null,[linkColor,isInlineLink,underlineOwnedByChild]),linkContent=!isInlineLink&&(iconLeft||iconRight)?React.createElement(React.Fragment,null,iconLeft&&React.createElement(StyledIcon,{"aria-hidden":!0,size:"s",name:iconLeft.name,color:iconLeft.color??linkColor,inline:!0,position:"left"}),children,iconRight&&React.createElement(StyledIcon,{"aria-hidden":!0,size:"s",name:iconRight.name,color:iconRight.color??linkColor,inline:!0,position:"right"})):children;return React.createElement(StyledLink,{"data-e2e-test-id":dataE2eTestId,"data-ds-id":"Link",ref:ref,inline:isInlineLink,color:linkColor,size:size||inheritPropsFromText?.size,weight:weight||inheritPropsFromText?.weight,...rest},React.createElement(LinkContext.Provider,{value:linkContextValue},linkContent))});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amboss/design-system",
-  "version": "4.0.6",
+  "version": "4.1.0",
   "description": "the design system for AMBOSS products",
   "author": "AMBOSS",
   "license": "ISC",
@@ -83,7 +83,7 @@
   },
   "scripts": {
     "prepare": "husky",
-    "clean": "rimraf build src/web-tokens",
+    "clean": "rm -rf build src/web-tokens",
     "build": "./scripts/build.sh",
     "predev": "bun run tokens:web",
     "dev": "bun run --parallel tokens:watch storybook",
@@ -154,7 +154,6 @@
     "qs": ">=6.14.2",
     "ajv": ">=6.14.0 <7.0.0",
     "micromatch": ">=4.0.8",
-    "brace-expansion": ">=2.0.2",
     "diff": ">=5.2.2",
     "lodash": "~4.18.1",
     "rollup": ">=4.59.0",
@@ -167,6 +166,7 @@
     "test-exclude": "~7.0.1"
   },
   "devDependencies": {
+    "@amboss/design-tokens": "0.1.0",
     "@auto-it/npm": "^11.1.6",
     "@auto-it/released": "^10.13.2",
     "@emotion/jest": "^11.11.0",
@@ -216,8 +216,8 @@
     "lint-staged": "^13.2.2",
     "lodash": "~4.18.1",
     "markdown-to-jsx": "^9.7.6",
-    "pdfkit": "^0.15.0",
-    "playwright": "^1.56.1",
+    "pdfkit": "^0.19.1",
+    "playwright": "1.61.0",
     "prettier": "^2.2.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -229,6 +229,7 @@
     "ts-jest": "^29.1.1",
     "tsc-alias": "^1.8.17",
     "typescript": "^5.3.3",
+    "vite": "^7.3.5",
     "vitest": "^3.2.4"
   },
   "homepage": "https://github.com/amboss-mededu/amboss-design-system#readme",