[] = [];
topBarItems: TopBarRegistration[] = [];
+ additionalCategoryColumns: AdditionalCategoryColumnRegistration[] = [];
async navigate(pageId?: string, params?: P) {
const { navigate } = await import("../renderer/navigation");
diff --git a/src/extensions/renderer-api/components.ts b/src/extensions/renderer-api/components.ts
index 3181e7144a..79372c71dd 100644
--- a/src/extensions/renderer-api/components.ts
+++ b/src/extensions/renderer-api/components.ts
@@ -31,6 +31,11 @@ export * from "../../renderer/components/input/input";
// command-overlay
export const CommandOverlay = asLegacyGlobalObjectForExtensionApi(commandOverlayInjectable);
+export type {
+ CategoryColumnRegistration,
+ AdditionalCategoryColumnRegistration,
+} from "../../renderer/components/+catalog/custom-category-columns";
+
// other components
export * from "../../renderer/components/icon";
export * from "../../renderer/components/tooltip";
diff --git a/src/extensions/renderer-extensions.injectable.ts b/src/extensions/renderer-extensions.injectable.ts
index 24e3bd0557..3f06df5ca8 100644
--- a/src/extensions/renderer-extensions.injectable.ts
+++ b/src/extensions/renderer-extensions.injectable.ts
@@ -8,10 +8,8 @@ import extensionsInjectable from "./extensions.injectable";
import type { LensRendererExtension } from "./lens-renderer-extension";
const rendererExtensionsInjectable = getInjectable({
+ instantiate: (di) => di.inject(extensionsInjectable) as IComputedValue,
lifecycle: lifecycleEnum.singleton,
-
- instantiate: (di) =>
- di.inject(extensionsInjectable) as IComputedValue,
});
export default rendererExtensionsInjectable;
diff --git a/src/renderer/components/+catalog/__tests__/custom-columns.test.ts b/src/renderer/components/+catalog/__tests__/custom-columns.test.ts
new file mode 100644
index 0000000000..00fd5e033b
--- /dev/null
+++ b/src/renderer/components/+catalog/__tests__/custom-columns.test.ts
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import type { ConfigurableDependencyInjectionContainer } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { CatalogCategorySpec } from "../../../../common/catalog";
+import type { LensRendererExtension } from "../../../../extensions/lens-renderer-extension";
+import rendererExtensionsInjectable from "../../../../extensions/renderer-extensions.injectable";
+import { CatalogCategory } from "../../../api/catalog-entity";
+import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
+import type { AdditionalCategoryColumnRegistration, CategoryColumnRegistration } from "../custom-category-columns";
+import getCategoryColumnsInjectable, { CategoryColumns, GetCategoryColumnsParams } from "../get-category-columns.injectable";
+
+class TestCategory extends CatalogCategory {
+ apiVersion = "catalog.k8slens.dev/v1alpha1";
+ kind = "CatalogCategory";
+ metadata: {
+ name: "Test";
+ icon: "question_mark";
+ };
+ spec: CatalogCategorySpec = {
+ group: "foo.bar.bat",
+ names: {
+ kind: "Test",
+ },
+ versions: [],
+ };
+
+ constructor(columns?: CategoryColumnRegistration[]) {
+ super();
+ this.spec.displayColumns = columns;
+ }
+}
+
+describe("Custom Category Columns", () => {
+ let di: ConfigurableDependencyInjectionContainer;
+
+ beforeEach(() => {
+ di = getDiForUnitTesting();
+ });
+
+ describe("without extensions", () => {
+ let getCategoryColumns: (params: GetCategoryColumnsParams) => CategoryColumns;
+
+ beforeEach(() => {
+ di.override(rendererExtensionsInjectable, () => computed(() => [] as LensRendererExtension[]));
+ getCategoryColumns = di.inject(getCategoryColumnsInjectable);
+ });
+
+ it("should contain a kind column if activeCategory is falsy", () => {
+ expect(getCategoryColumns({ activeCategory: null }).renderTableHeader.find(elem => elem.title === "Kind")).toBeTruthy();
+ });
+
+ it("should not contain a kind column if activeCategory is truthy", () => {
+ expect(getCategoryColumns({ activeCategory: new TestCategory() }).renderTableHeader.find(elem => elem.title === "Kind")).toBeFalsy();
+ });
+
+ it("should include the default columns if the provided category doesn't provide any", () => {
+ expect(getCategoryColumns({ activeCategory: new TestCategory() }).renderTableHeader.find(elem => elem.title === "Source")).toBeTruthy();
+ });
+
+ it("should not include the default columns if the provided category provides any", () => {
+ expect(getCategoryColumns({ activeCategory: new TestCategory([]) }).renderTableHeader.find(elem => elem.title === "Source")).toBeFalsy();
+ });
+
+ it("should include the displayColumns from the provided category", () => {
+ const columns: CategoryColumnRegistration[] = [
+ {
+ id: "foo",
+ renderCell: () => null,
+ titleProps: {
+ title: "Foo",
+ },
+ },
+ ];
+
+ expect(getCategoryColumns({ activeCategory: new TestCategory(columns) }).renderTableHeader.find(elem => elem.title === "Foo")).toBeTruthy();
+ });
+ });
+
+ describe("with extensions", () => {
+ let getCategoryColumns: (params: GetCategoryColumnsParams) => CategoryColumns;
+
+ beforeEach(() => {
+ di.override(rendererExtensionsInjectable, () => computed(() => [
+ {
+ name: "test-extension",
+ additionalCategoryColumns: [
+ {
+ group: "foo.bar.bat",
+ id: "high",
+ kind: "Test",
+ renderCell: () => "",
+ titleProps: {
+ title: "High",
+ },
+ } as AdditionalCategoryColumnRegistration,
+ {
+ group: "foo.bar",
+ id: "high",
+ kind: "Test",
+ renderCell: () => "",
+ titleProps: {
+ title: "High2",
+ },
+ } as AdditionalCategoryColumnRegistration,
+ ],
+ } as LensRendererExtension,
+ ]));
+ getCategoryColumns = di.inject(getCategoryColumnsInjectable);
+ });
+
+ it("should include columns from extensions that match", () => {
+ expect(getCategoryColumns({ activeCategory: new TestCategory() }).renderTableHeader.find(elem => elem.title === "High")).toBeTruthy();
+ });
+
+ it("should not include columns from extensions that don't match", () => {
+ expect(getCategoryColumns({ activeCategory: new TestCategory() }).renderTableHeader.find(elem => elem.title === "High2")).toBeFalsy();
+ });
+ });
+});
diff --git a/src/renderer/components/+catalog/catalog.tsx b/src/renderer/components/+catalog/catalog.tsx
index ae6ab3795f..107e02db30 100644
--- a/src/renderer/components/+catalog/catalog.tsx
+++ b/src/renderer/components/+catalog/catalog.tsx
@@ -28,25 +28,18 @@ import { RenderDelay } from "../render-delay/render-delay";
import { Icon } from "../icon";
import { HotbarToggleMenuItem } from "./hotbar-toggle-menu-item";
import { Avatar } from "../avatar";
-import { KubeObject } from "../../../common/k8s-api/kube-object";
-import { getLabelBadges } from "./helpers";
import { withInjectables } from "@ogre-tools/injectable-react";
-import catalogPreviousActiveTabStorageInjectable
- from "./catalog-previous-active-tab-storage/catalog-previous-active-tab-storage.injectable";
+import catalogPreviousActiveTabStorageInjectable from "./catalog-previous-active-tab-storage/catalog-previous-active-tab-storage.injectable";
import catalogEntityStoreInjectable from "./catalog-entity-store/catalog-entity-store.injectable";
-
-enum sortBy {
- name = "name",
- kind = "kind",
- source = "source",
- status = "status",
-}
+import type { GetCategoryColumnsParams, CategoryColumns } from "./get-category-columns.injectable";
+import getCategoryColumnsInjectable from "./get-category-columns.injectable";
interface Props extends RouteComponentProps {}
interface Dependencies {
- catalogPreviousActiveTabStorage: { set: (value: string ) => void }
- catalogEntityStore: CatalogEntityStore
+ catalogPreviousActiveTabStorage: { set: (value: string ) => void };
+ catalogEntityStore: CatalogEntityStore;
+ getCategoryColumns: (params: GetCategoryColumnsParams) => CategoryColumns;
}
@observer
@@ -228,46 +221,23 @@ class NonInjectedCatalog extends React.Component {
return null;
}
+ const { sortingCallbacks, searchFilters, renderTableContents, renderTableHeader } = this.props.getCategoryColumns({ activeCategory });
+
return (
entity.getName(),
- [sortBy.source]: entity => entity.getSource(),
- [sortBy.status]: entity => entity.status.phase,
- [sortBy.kind]: entity => entity.kind,
- }}
- searchFilters={[
- entity => [
- entity.getName(),
- entity.getId(),
- entity.status.phase,
- `source=${entity.getSource()}`,
- ...KubeObject.stringifyLabels(entity.metadata.labels),
- ],
- ]}
- renderTableHeader={[
- { title: "Name", className: styles.entityName, sortBy: sortBy.name, id: "name" },
- !activeCategory && { title: "Kind", sortBy: sortBy.kind, id: "kind" },
- { title: "Source", className: styles.sourceCell, sortBy: sortBy.source, id: "source" },
- { title: "Labels", className: `${styles.labelsCell} scrollable`, id: "labels" },
- { title: "Status", className: styles.statusCell, sortBy: sortBy.status, id: "status" },
- ].filter(Boolean)}
+ sortingCallbacks={sortingCallbacks}
+ searchFilters={searchFilters}
+ renderTableHeader={renderTableHeader}
customizeTableRowProps={entity => ({
disabled: !entity.isEnabled(),
})}
- renderTableContents={entity => [
- this.renderName(entity),
- !activeCategory && entity.kind,
- entity.getSource(),
- getLabelBadges(entity),
- {entity.status.phase},
- ].filter(Boolean)}
+ renderTableContents={renderTableContents}
onDetails={this.onDetails}
renderItemMenu={this.renderItemMenu}
/>
@@ -306,17 +276,11 @@ class NonInjectedCatalog extends React.Component {
}
}
-export const Catalog = withInjectables(
- NonInjectedCatalog,
- {
- getProps: (di, props) => ({
- catalogEntityStore: di.inject(catalogEntityStoreInjectable),
-
- catalogPreviousActiveTabStorage: di.inject(
- catalogPreviousActiveTabStorageInjectable,
- ),
-
- ...props,
- }),
- },
-);
+export const Catalog = withInjectables( NonInjectedCatalog, {
+ getProps: (di, props) => ({
+ catalogEntityStore: di.inject(catalogEntityStoreInjectable),
+ catalogPreviousActiveTabStorage: di.inject(catalogPreviousActiveTabStorageInjectable),
+ getCategoryColumns: di.inject(getCategoryColumnsInjectable),
+ ...props,
+ }),
+});
diff --git a/src/renderer/components/+catalog/custom-category-columns.injectable.tsx b/src/renderer/components/+catalog/custom-category-columns.injectable.tsx
new file mode 100644
index 0000000000..26d4a304d7
--- /dev/null
+++ b/src/renderer/components/+catalog/custom-category-columns.injectable.tsx
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { computed, IComputedValue } from "mobx";
+import type { LensRendererExtension } from "../../../extensions/lens-renderer-extension";
+import rendererExtensionsInjectable from "../../../extensions/renderer-extensions.injectable";
+import { getOrInsert } from "../../utils";
+import type { RegisteredAdditionalCategoryColumn } from "./custom-category-columns";
+
+interface Dependencies {
+ extensions: IComputedValue;
+}
+
+function getAdditionCategoryColumns({ extensions }: Dependencies): IComputedValue>> {
+ return computed(() => {
+ const res = new Map>();
+
+ for (const ext of extensions.get()) {
+ for (const { renderCell, titleProps, priority = 50, searchFilter, sortCallback, ...registration } of ext.additionalCategoryColumns) {
+ const byGroup = getOrInsert(res, registration.group, new Map());
+ const byKind = getOrInsert(byGroup, registration.kind, []);
+ const id = `${ext.name}:${registration.id}`;
+
+ byKind.push({
+ renderCell,
+ priority,
+ id,
+ titleProps: {
+ id,
+ ...titleProps,
+ sortBy: sortCallback
+ ? id
+ : undefined,
+ },
+ searchFilter,
+ sortCallback,
+ });
+ }
+ }
+
+ return res;
+ });
+}
+
+const categoryColumnsInjectable = getInjectable({
+ instantiate: (di) => getAdditionCategoryColumns({
+ extensions: di.inject(rendererExtensionsInjectable),
+ }),
+ lifecycle: lifecycleEnum.singleton,
+});
+
+export default categoryColumnsInjectable;
diff --git a/src/renderer/components/+catalog/custom-category-columns.ts b/src/renderer/components/+catalog/custom-category-columns.ts
new file mode 100644
index 0000000000..3d8a832ac0
--- /dev/null
+++ b/src/renderer/components/+catalog/custom-category-columns.ts
@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import type React from "react";
+import type { CatalogEntity } from "../../../common/catalog";
+import type { TableCellProps } from "../table";
+
+/**
+ * These are the supported props for the title cell
+ */
+export interface TitleCellProps {
+ className?: string;
+ title: React.ReactNode;
+}
+
+export interface CategoryColumnRegistration {
+ /**
+ * The sorting order value.
+ *
+ * @default 50
+ */
+ priority?: number;
+
+ /**
+ * This value MUST to be unique to your extension
+ */
+ id: string;
+
+ /**
+ * This function will be called to generate the cells (on demand) for the column
+ */
+ renderCell: (entity: CatalogEntity) => React.ReactNode;
+
+ /**
+ * This function will be used to generate the columns title cell.
+ */
+ titleProps: TitleCellProps;
+
+ /**
+ * If provided then the column will support sorting and this function will be called to
+ * determine a row's ordering.
+ *
+ * strings are sorted ahead of numbers, and arrays determine ordering between equal
+ * elements of the previous index.
+ */
+ sortCallback?: (entity: CatalogEntity) => string | number | (string | number)[];
+
+ /**
+ * If provided then searching is supported on this column and this function will be called
+ * to determine if the current search string matches for this row.
+ */
+ searchFilter?: (entity: CatalogEntity) => string | string[];
+}
+
+/**
+ * This is the type used to declare new catalog category columns
+ */
+export interface AdditionalCategoryColumnRegistration extends CategoryColumnRegistration {
+ /**
+ * The catalog entity kind that is declared by the category for this registration
+ *
+ * e.g.
+ * - `"KubernetesCluster"`
+ */
+ kind: string;
+
+ /**
+ * The catalog entity group that is declared by the category for this registration
+ *
+ * e.g.
+ * - `"entity.k8slens.dev"`
+ */
+ group: string;
+}
+
+export interface RegisteredAdditionalCategoryColumn {
+ id: string;
+ priority: number;
+ renderCell: (entity: CatalogEntity) => React.ReactNode;
+ titleProps: TableCellProps;
+ sortCallback?: (entity: CatalogEntity) => string | number | (string | number)[];
+ searchFilter?: (entity: CatalogEntity) => string | string[];
+}
diff --git a/src/renderer/components/+catalog/get-category-columns.injectable.ts b/src/renderer/components/+catalog/get-category-columns.injectable.ts
new file mode 100644
index 0000000000..66fe0cddee
--- /dev/null
+++ b/src/renderer/components/+catalog/get-category-columns.injectable.ts
@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { orderBy } from "lodash";
+import type { IComputedValue } from "mobx";
+import type { CatalogCategory, CatalogEntity } from "../../../common/catalog";
+import { bind } from "../../utils";
+import type { ItemListLayoutProps } from "../item-object-list";
+import type { RegisteredAdditionalCategoryColumn } from "./custom-category-columns";
+import categoryColumnsInjectable from "./custom-category-columns.injectable";
+import { defaultCategoryColumns, browseAllColumns, nameCategoryColumn } from "./internal-category-columns";
+
+interface Dependencies {
+ extensionColumns: IComputedValue>>;
+}
+
+export interface GetCategoryColumnsParams {
+ activeCategory: CatalogCategory | null | undefined;
+}
+
+export type CategoryColumns = Required, "sortingCallbacks" | "searchFilters" | "renderTableContents" | "renderTableHeader">>;
+
+function getSpecificCategoryColumns(activeCategory: CatalogCategory, extensionColumns: IComputedValue>>): RegisteredAdditionalCategoryColumn[] {
+ const fromExtensions = (
+ extensionColumns
+ .get()
+ .get(activeCategory.spec.group)
+ ?.get(activeCategory.spec.names.kind)
+ ?? []
+ );
+ const fromCategory = activeCategory.spec.displayColumns?.map(({ priority = 50, ...column }) => ({
+ priority,
+ ...column,
+ })) ?? defaultCategoryColumns;
+
+ return [
+ nameCategoryColumn,
+ ...fromExtensions,
+ ...fromCategory,
+ ];
+}
+
+function getBrowseAllColumns(): RegisteredAdditionalCategoryColumn[] {
+ return [
+ ...browseAllColumns,
+ nameCategoryColumn,
+ ...defaultCategoryColumns,
+ ];
+}
+
+function getCategoryColumns({ extensionColumns }: Dependencies, { activeCategory }: GetCategoryColumnsParams): CategoryColumns {
+ const allRegistrations = orderBy(
+ activeCategory
+ ? getSpecificCategoryColumns(activeCategory, extensionColumns)
+ : getBrowseAllColumns(),
+ "priority",
+ "asc",
+ );
+
+ const sortingCallbacks: CategoryColumns["sortingCallbacks"] = {};
+ const searchFilters: CategoryColumns["searchFilters"] = [];
+ const renderTableHeader: CategoryColumns["renderTableHeader"] = [];
+ const tableRowRenderers: ((entity: CatalogEntity) => React.ReactNode)[] = [];
+
+ for (const registration of allRegistrations) {
+ if (registration.sortCallback) {
+ sortingCallbacks[registration.id] = registration.sortCallback;
+ }
+
+ if (registration.searchFilter) {
+ searchFilters.push(registration.searchFilter);
+ }
+
+ tableRowRenderers.push(registration.renderCell);
+ renderTableHeader.push(registration.titleProps);
+ }
+
+ return {
+ sortingCallbacks,
+ renderTableHeader,
+ renderTableContents: entity => tableRowRenderers.map(fn => fn(entity)),
+ searchFilters,
+ };
+}
+
+const getCategoryColumnsInjectable = getInjectable({
+ instantiate: (di) => bind(getCategoryColumns, null, {
+ extensionColumns: di.inject(categoryColumnsInjectable),
+ }),
+ lifecycle: lifecycleEnum.singleton,
+});
+
+export default getCategoryColumnsInjectable;
diff --git a/src/renderer/components/+catalog/internal-category-columns.tsx b/src/renderer/components/+catalog/internal-category-columns.tsx
new file mode 100644
index 0000000000..6aee0acc1d
--- /dev/null
+++ b/src/renderer/components/+catalog/internal-category-columns.tsx
@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import styles from "./catalog.module.scss";
+
+import React from "react";
+import { HotbarStore } from "../../../common/hotbar-store";
+import type { CatalogEntity } from "../../api/catalog-entity";
+import { Avatar } from "../avatar";
+import type { RegisteredAdditionalCategoryColumn } from "./custom-category-columns";
+import { Icon } from "../icon";
+import { prevDefault } from "../../utils";
+import { getLabelBadges } from "./helpers";
+import { KubeObject } from "../../../common/k8s-api/kube-object";
+
+function renderEntityName(entity: CatalogEntity) {
+ const hotbarStore = HotbarStore.getInstance();
+ const isItemInHotbar = hotbarStore.isAddedToActive(entity);
+ const onClick = prevDefault(
+ isItemInHotbar
+ ? () => hotbarStore.removeFromHotbar(entity.getId())
+ : () => hotbarStore.addToHotbar(entity),
+ );
+
+ return (
+ <>
+
+ {entity.spec.icon?.material && }
+
+ {entity.getName()}
+
+
+ );
+}
+
+export const browseAllColumns: RegisteredAdditionalCategoryColumn[] = [
+ {
+ id: "kind",
+ priority: 5,
+ renderCell: entity => entity.kind,
+ titleProps: {
+ id: "kind",
+ sortBy: "kind",
+ title: "Kind",
+ },
+ sortCallback: entity => entity.kind,
+ },
+];
+
+export const nameCategoryColumn: RegisteredAdditionalCategoryColumn = {
+ id: "name",
+ priority: 0,
+ renderCell: renderEntityName,
+ titleProps: {
+ title: "Name",
+ className: styles.entityName,
+ id: "name",
+ sortBy: "name",
+ },
+ searchFilter: entity => entity.getName(),
+ sortCallback: entity => `name=${entity.getName()}`,
+};
+
+export const defaultCategoryColumns: RegisteredAdditionalCategoryColumn[] = [
+ {
+ id: "source",
+ priority: 10,
+ renderCell: entity => entity.getSource(),
+ titleProps: {
+ title: "Source",
+ className: styles.sourceCell,
+ id: "source",
+ sortBy: "source",
+ },
+ sortCallback: entity => entity.getSource(),
+ searchFilter: entity => `source=${entity.getSource()}`,
+ },
+ {
+ id: "labels",
+ priority: 20,
+ renderCell: getLabelBadges,
+ titleProps: {
+ id: "labels",
+ title: "Labels",
+ className: `${styles.labelsCell} scrollable`,
+ },
+ searchFilter: entity => KubeObject.stringifyLabels(entity.metadata.labels),
+ },
+ {
+ id: "status",
+ priority: 30,
+ renderCell: entity => (
+
+ {entity.status.phase}
+
+ ),
+ titleProps: {
+ title: "Status",
+ className: styles.statusCell,
+ id: "status",
+ sortBy: "status",
+ },
+ searchFilter: entity => entity.status.phase,
+ },
+];
diff --git a/src/renderer/components/table/table-cell.tsx b/src/renderer/components/table/table-cell.tsx
index 6165cd81ed..af6f95eec9 100644
--- a/src/renderer/components/table/table-cell.tsx
+++ b/src/renderer/components/table/table-cell.tsx
@@ -14,18 +14,66 @@ import { Checkbox } from "../checkbox";
export type TableCellElem = React.ReactElement;
export interface TableCellProps extends React.DOMAttributes {
- id?: string; // used for configuration visibility of columns
+ /**
+ * used for configuration visibility of columns
+ */
+ id?: string;
+
+ /**
+ * Any css class names for this table cell. Only used if `title` is a "simple" react node
+ */
className?: string;
+
+ /**
+ * The actual value of the cell
+ */
title?: ReactNode;
- scrollable?: boolean; // content inside could be scrolled
- checkbox?: boolean; // render cell with a checkbox
- isChecked?: boolean; // mark checkbox as checked or not
- renderBoolean?: boolean; // show "true" or "false" for all of the children elements are "typeof boolean"
- sortBy?: TableSortBy; // column name, must be same as key in sortable object
- showWithColumn?: string // id of the column which follow same visibility rules
- _sorting?: Partial; // sorting state, don't use this prop outside (!)
- _sort?(sortBy: TableSortBy): void; // sort function, don't use this prop outside (!)
- _nowrap?: boolean; // indicator, might come from parent , don't use this prop outside (!)
+
+ /**
+ * content inside could be scrolled
+ */
+ scrollable?: boolean;
+
+ /**
+ * render cell with a checkbox
+ */
+ checkbox?: boolean;
+
+ /**
+ * mark checkbox as checked or not
+ */
+ isChecked?: boolean;
+
+ /**
+ * show "true" or "false" for all of the children elements are "typeof boolean"
+ */
+ renderBoolean?: boolean;
+
+ /**
+ * column name, must be same as key in sortable object
+ */
+ sortBy?: TableSortBy;
+
+ /**
+ * id of the column which follow same visibility rules
+ */
+ showWithColumn?: string
+
+ /**
+ * @internal
+ */
+ _sorting?: Partial;
+
+ /**
+ * @internal
+ */
+ _sort?(sortBy: TableSortBy): void;
+
+ /**
+ * @internal
+ * indicator, might come from parent , don't use this prop outside (!)
+ */
+ _nowrap?: boolean;
}
export class TableCell extends React.Component {