Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Allow pinned collection items to be selected alongside table rows (#79614)

Anderson32d8cbe5d88e
diff --git a/e2e/support/helpers/e2e-collection-helpers.ts b/e2e/support/helpers/e2e-collection-helpers.ts
index a5040190411..91054212285 100644
--- a/e2e/support/helpers/e2e-collection-helpers.ts
+++ b/e2e/support/helpers/e2e-collection-helpers.ts
@@ -68,10 +68,13 @@ export const openPinnedItemMenu = (name: string) => {
// Hover first so the button settles, then realClick: the real pointer
// movement re-applies :hover to the current node, so the click cannot race
// the visibility toggle.
- getPinnedSection().findByText(name).closest("a").realHover();
getPinnedSection()
.findByText(name)
- .closest("a")
+ .closest('[data-testid="pinned-item-card"]')
+ .realHover();
+ getPinnedSection()
+ .findByText(name)
+ .closest('[data-testid="pinned-item-card"]')
.findByLabelText("Actions")
.realClick();
};
diff --git a/e2e/test/scenarios/collections/collections.cy.spec.js b/e2e/test/scenarios/collections/collections.cy.spec.js
index f7b9d558403..592747bbd40 100644
--- a/e2e/test/scenarios/collections/collections.cy.spec.js
+++ b/e2e/test/scenarios/collections/collections.cy.spec.js
@@ -817,22 +817,36 @@ describe("scenarios > collection defaults", () => {
// Select one
selectItemUsingCheckbox("Orders");
- // eslint-disable-next-line metabase/no-unscoped-text-selectors -- deprecated usage
- cy.findByText("1 item selected").should("be.visible");
+ cy.findByTestId("toast-card")
+ .findByText("1 item selected")
+ .should("be.visible");
assertSelectAllIsIndeterminate(true);
getRowCheckbox("Orders").should("be.checked");
+ // pinned cards join the same selection
+ H.getPinnedSection()
+ .findByRole("checkbox", { name: "Orders, Count" })
+ .click();
+ cy.findByTestId("toast-card")
+ .findByText("2 items selected")
+ .should("be.visible");
+ assertSelectAllIsIndeterminate(true);
+
// Select all
cy.findByLabelText("Select all items").click();
assertSelectAllIsIndeterminate(false);
- cy.findByTestId("toast-card").findByText(/\d+ items selected/);
+ H.getPinnedSection()
+ .findByRole("checkbox", { name: "Orders, Count" })
+ .should("have.attr", "aria-checked", "true");
+ cy.findByTestId("toast-card")
+ .findByText(/\d+ items selected/)
+ .should("be.visible");
// Deselect all
cy.findByLabelText("Select all items").click();
cy.findAllByRole("checkbox").should("not.be.checked");
- // eslint-disable-next-line metabase/no-unscoped-text-selectors -- deprecated usage
- cy.findByText(/item(s)? selected/).should("not.exist");
+ cy.findByTestId("toast-card").should("not.exist");
});
it("should clean up selection when opening another collection (metabase#16491)", () => {
diff --git a/e2e/test/scenarios/metrics/metrics-dimensions.cy.spec.ts b/e2e/test/scenarios/metrics/metrics-dimensions.cy.spec.ts
index 40fa5cf0db8..596c563dfa0 100644
--- a/e2e/test/scenarios/metrics/metrics-dimensions.cy.spec.ts
+++ b/e2e/test/scenarios/metrics/metrics-dimensions.cy.spec.ts
@@ -256,7 +256,11 @@ describe("scenarios > metrics > dimensions", () => {
});
it("uses a time dimension's configured bucket on the About page", () => {
- cy.intercept("POST", "/api/metric/dataset").as("metricDataset");
+ cy.intercept("POST", "/api/metric/dataset", (request) => {
+ if (request.body.definition?.projections?.length > 0) {
+ request.alias = "metricDataset";
+ }
+ });
cy.visit(`/metric/${metricId}/dimensions`);
cy.wait("@listDimensions");
diff --git a/frontend/src/metabase/collections/components/CollectionContent/CollectionContentSelection.unit.spec.tsx b/frontend/src/metabase/collections/components/CollectionContent/CollectionContentSelection.unit.spec.tsx
new file mode 100644
index 00000000000..05fede73aa9
--- /dev/null
+++ b/frontend/src/metabase/collections/components/CollectionContent/CollectionContentSelection.unit.spec.tsx
@@ -0,0 +1,282 @@
+import userEvent from "@testing-library/user-event";
+
+import {
+ setupBookmarksEndpoints,
+ setupCollectionByIdEndpoint,
+ setupCollectionItemsEndpoint,
+ setupCollectionsEndpoints,
+ setupDashboardQuestionCandidatesEndpoint,
+ setupDatabasesEndpoints,
+ setupNullGetUserKeyValueEndpoints,
+ setupSearchEndpoints,
+ setupUserMetabotPermissionsEndpoint,
+} from "__support__/server-mocks";
+import { renderWithProviders, screen, within } from "__support__/ui";
+import { Route } from "metabase/router";
+import type { Collection, CollectionItem } from "metabase-types/api";
+import {
+ createMockCollection,
+ createMockCollectionItem,
+} from "metabase-types/api/mocks";
+
+import { CollectionContent } from "./CollectionContent";
+
+const defaultCollection = createMockCollection({
+ id: 1,
+ name: "Selection collection",
+ can_write: true,
+});
+
+const pinnedDashboard = createMockCollectionItem({
+ id: 1,
+ name: "Pinned dashboard",
+ model: "dashboard",
+ collection_position: 1,
+});
+
+const pinnedQuestion = createMockCollectionItem({
+ id: 2,
+ name: "Pinned question",
+ model: "card",
+ collection_position: 2,
+});
+
+const tableQuestion = createMockCollectionItem({
+ id: 3,
+ name: "Table question",
+ model: "card",
+ collection_position: null,
+});
+
+const tableDashboard = createMockCollectionItem({
+ id: 4,
+ name: "Table dashboard",
+ model: "dashboard",
+ collection_position: null,
+});
+
+const defaultItems = [
+ pinnedDashboard,
+ pinnedQuestion,
+ tableQuestion,
+ tableDashboard,
+];
+
+async function setup({
+ collection = defaultCollection,
+ collectionItems = defaultItems,
+}: {
+ collection?: Collection;
+ collectionItems?: CollectionItem[];
+} = {}) {
+ setupCollectionByIdEndpoint({ collections: [collection] });
+ setupCollectionsEndpoints({ collections: [collection] });
+ setupCollectionItemsEndpoint({ collection, collectionItems });
+ setupBookmarksEndpoints([]);
+ setupDatabasesEndpoints([]);
+ setupSearchEndpoints([]);
+ setupNullGetUserKeyValueEndpoints();
+ setupDashboardQuestionCandidatesEndpoint([]);
+ setupUserMetabotPermissionsEndpoint();
+
+ renderWithProviders(
+ <Route
+ path="/"
+ element={<CollectionContent collectionId={collection.id} />}
+ />,
+ { withRouter: true, withDND: true },
+ );
+
+ await screen.findByTestId("pinned-items");
+ await screen.findByText(tableQuestion.name);
+}
+
+function getRowSelectionCell(itemName: string) {
+ const row = screen.getByRole("row", { name: new RegExp(itemName) });
+ return within(row).getByTestId("collection-entry-check");
+}
+
+function getRowSelectionButton(itemName: string) {
+ return within(getRowSelectionCell(itemName)).getByRole("button");
+}
+
+function getRowSelectionCheckbox(itemName: string) {
+ return within(getRowSelectionCell(itemName)).getByRole("checkbox");
+}
+
+function getPinnedSection() {
+ return within(screen.getByTestId("pinned-items"));
+}
+
+function getPinnedCard(itemName: string) {
+ return getPinnedSection().getByRole("checkbox", { name: itemName });
+}
+
+function getPinnedLink(itemName: string) {
+ return getPinnedSection().getByRole("link", { name: new RegExp(itemName) });
+}
+
+describe("CollectionContent selection", () => {
+ it("should render pinned cards as links when nothing is selected", async () => {
+ await setup();
+
+ expect(getPinnedLink(pinnedDashboard.name)).toBeInTheDocument();
+ expect(getPinnedLink(pinnedQuestion.name)).toBeInTheDocument();
+ expect(
+ getPinnedSection().queryByRole("checkbox", {
+ name: pinnedDashboard.name,
+ }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should list pinned items as table rows as well as pinned cards", async () => {
+ await setup();
+
+ expect(
+ screen.getByRole("row", { name: new RegExp(pinnedDashboard.name) }),
+ ).toBeInTheDocument();
+ expect(getPinnedLink(pinnedDashboard.name)).toBeInTheDocument();
+ });
+
+ it("should check the table row of a pinned item selected from its card", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+
+ expect(await screen.findByText("2 items selected")).toBeInTheDocument();
+ expect(getRowSelectionCheckbox(pinnedDashboard.name)).toBeChecked();
+ });
+
+ it("should check the pinned card of an item selected from its table row", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(pinnedDashboard.name));
+
+ expect(await screen.findByText("1 item selected")).toBeInTheDocument();
+ expect(getPinnedCard(pinnedDashboard.name)).toBeChecked();
+ });
+
+ it("should toggle the same selection entry from either representation", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(pinnedDashboard.name));
+ expect(await screen.findByText("1 item selected")).toBeInTheDocument();
+
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+
+ expect(screen.queryByText(/items? selected/)).not.toBeInTheDocument();
+ expect(getRowSelectionCheckbox(pinnedDashboard.name)).not.toBeChecked();
+ });
+
+ it("should add a pinned card to the same selection as a table row", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ expect(await screen.findByText("1 item selected")).toBeInTheDocument();
+
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+
+ expect(await screen.findByText("2 items selected")).toBeInTheDocument();
+ expect(getPinnedCard(pinnedDashboard.name)).toBeChecked();
+ });
+
+ it("should toggle a selected pinned card off", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+ expect(await screen.findByText("2 items selected")).toBeInTheDocument();
+
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+
+ expect(await screen.findByText("1 item selected")).toBeInTheDocument();
+ expect(getPinnedCard(pinnedDashboard.name)).not.toBeChecked();
+ });
+
+ it("should select every listed item exactly once with select all", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ await userEvent.click(screen.getByLabelText("Select all items"));
+
+ expect(await screen.findByText("4 items selected")).toBeInTheDocument();
+ expect(screen.getByLabelText("Select all items")).toBeChecked();
+ expect(
+ screen.getByLabelText("Select all items"),
+ ).not.toBePartiallyChecked();
+ expect(getPinnedCard(pinnedDashboard.name)).toBeChecked();
+ expect(getPinnedCard(pinnedQuestion.name)).toBeChecked();
+ });
+
+ it("should select every listed item exactly once with select all from an empty selection", async () => {
+ await setup();
+
+ await userEvent.click(screen.getByLabelText("Select all items"));
+
+ expect(await screen.findByText("4 items selected")).toBeInTheDocument();
+ expect(getPinnedCard(pinnedDashboard.name)).toBeChecked();
+ expect(getPinnedCard(pinnedQuestion.name)).toBeChecked();
+ });
+
+ it("should keep the header checkbox indeterminate while pinned rows stay unselected", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ await userEvent.click(getRowSelectionButton(tableDashboard.name));
+
+ expect(await screen.findByText("2 items selected")).toBeInTheDocument();
+ expect(screen.getByLabelText("Select all items")).toBePartiallyChecked();
+
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+ await userEvent.click(getPinnedCard(pinnedQuestion.name));
+
+ expect(await screen.findByText("4 items selected")).toBeInTheDocument();
+ expect(
+ screen.getByLabelText("Select all items"),
+ ).not.toBePartiallyChecked();
+ });
+
+ it("should complete select all from a pinned-only selection", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ await userEvent.click(getPinnedCard(pinnedDashboard.name));
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+
+ expect(await screen.findByText("1 item selected")).toBeInTheDocument();
+ expect(screen.getByLabelText("Select all items")).toBeChecked();
+ expect(screen.getByLabelText("Select all items")).toBePartiallyChecked();
+
+ await userEvent.click(screen.getByLabelText("Select all items"));
+
+ expect(await screen.findByText("4 items selected")).toBeInTheDocument();
+ });
+
+ it("should restore pinned card navigation after deselecting all", async () => {
+ await setup();
+
+ await userEvent.click(getRowSelectionButton(tableQuestion.name));
+ await userEvent.click(screen.getByLabelText("Select all items"));
+ expect(await screen.findByText("4 items selected")).toBeInTheDocument();
+
+ await userEvent.click(screen.getByLabelText("Select all items"));
+
+ expect(await getPinnedSection().findAllByRole("link")).toHaveLength(2);
+ expect(getPinnedSection().queryByRole("checkbox")).not.toBeInTheDocument();
+ expect(screen.queryByText(/items? selected/)).not.toBeInTheDocument();
+ });
+
+ it("should not expose selection in a read-only collection", async () => {
+ await setup({
+ collection: createMockCollection({
+ ...defaultCollection,
+ can_write: false,
+ }),
+ });
+
+ expect(screen.getByText(tableQuestion.name)).toBeInTheDocument();
+ expect(getPinnedSection().getAllByRole("link")).toHaveLength(2);
+ expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+ });
+});
diff --git a/frontend/src/metabase/collections/components/CollectionContent/CollectionContentView.tsx b/frontend/src/metabase/collections/components/CollectionContent/CollectionContentView.tsx
index e0364c0f20f..751dfc6ec7e 100644
--- a/frontend/src/metabase/collections/components/CollectionContent/CollectionContentView.tsx
+++ b/frontend/src/metabase/collections/components/CollectionContent/CollectionContentView.tsx
@@ -291,6 +291,9 @@ export const CollectionContentView = ({
collection={collection}
onMove={handleMove}
onCopy={handleCopy}
+ selected={selected}
+ getIsSelected={getIsSelected}
+ onToggleSelected={toggleItem}
/>
</ErrorBoundary>
<ErrorBoundary>
diff --git a/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.tsx b/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.tsx
index d461a0e9c5d..e79473a2d8a 100644
--- a/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.tsx
+++ b/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.tsx
@@ -8,8 +8,10 @@ import PinDropZone from "metabase/common/collections/components/PinDropZone";
import type {
CreateBookmark,
DeleteBookmark,
+ OnToggleSelectedWithItem,
} from "metabase/common/collections/types";
import { isRootTrashCollection } from "metabase/common/collections/utils";
+import { canSelectItems } from "metabase/common/components/ItemsTable/utils";
import { ItemDragSource } from "metabase/common/components/dnd/ItemDragSource";
import { Box, SimpleGrid, rem } from "metabase/ui";
import type Database from "metabase-lib/v1/metadata/Database";
@@ -29,6 +31,9 @@ type Props = {
collection: Collection;
onCopy: (items: CollectionItem[]) => void;
onMove: (items: CollectionItem[]) => void;
+ selected: CollectionItem[];
+ getIsSelected: (item: CollectionItem) => boolean;
+ onToggleSelected: OnToggleSelectedWithItem;
};
export function PinnedItemsGrid({
@@ -40,6 +45,9 @@ export function PinnedItemsGrid({
collection,
onCopy,
onMove,
+ selected,
+ getIsSelected,
+ onToggleSelected,
}: Props) {
// Trashed items keep their pin position, but the trash never shows a pinned section.
const showPinnedItems = !isRootTrashCollection(collection);
@@ -68,6 +76,9 @@ export function PinnedItemsGrid({
);
}
+ const canSelect = canSelectItems(collection, onToggleSelected);
+ const isSelectMode = canSelect && selected.length > 0;
+
return (
<Box mb={rem(48)} pos="relative" data-testid="pinned-items">
<PinDropZone variant="pin" />
@@ -76,6 +87,7 @@ export function PinnedItemsGrid({
// collection_position isn't guaranteed unique, so drag and drop is
// keyed by display index instead.
const pinIndex = index + 1;
+ const isSelected = getIsSelected(item);
return (
<Box key={`${item.model}-${item.id}`} pos="relative">
<PinnedItemSortDropTarget
@@ -86,6 +98,8 @@ export function PinnedItemsGrid({
<ItemDragSource
item={{ ...item, collection_position: pinIndex }}
collection={collection}
+ isSelected={isSelected}
+ selected={selected}
>
{/* ItemDragSource needs a native DOM element to attach its drag ref */}
<div data-drag-source-node>
@@ -98,6 +112,9 @@ export function PinnedItemsGrid({
deleteBookmark={deleteBookmark}
onCopy={onCopy}
onMove={onMove}
+ isSelectMode={isSelectMode}
+ isSelected={isSelected}
+ onToggleSelected={canSelect ? onToggleSelected : undefined}
/>
</div>
</ItemDragSource>
diff --git a/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.unit.spec.tsx b/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.unit.spec.tsx
index 86c75382207..59281d2d6da 100644
--- a/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.unit.spec.tsx
+++ b/frontend/src/metabase/collections/components/PinnedItemsGrid/PinnedItemsGrid.unit.spec.tsx
@@ -1,5 +1,8 @@
+import userEvent from "@testing-library/user-event";
+
import { setupCollectionItemsEndpoint } from "__support__/server-mocks";
import { renderWithProviders, screen, within } from "__support__/ui";
+import type { OnToggleSelectedWithItem } from "metabase/common/collections/types";
import type { Collection, CollectionItem } from "metabase-types/api";
import {
createMockCollection,
@@ -27,7 +30,7 @@ const dashboardItem = createMockCollectionItem({
});
const metricItem = createMockCollectionItem({
- id: 2,
+ id: 1,
model: "metric",
collection_position: 1,
name: "Metric Bar",
@@ -49,13 +52,20 @@ const modelItem = createMockCollectionItem({
const defaultItems = [dashboardItem, metricItem, questionItem, modelItem];
-function setup({
- items,
- collection,
-}: { items?: CollectionItem[]; collection?: Collection } = {}) {
- items = items || defaultItems;
- collection = collection || defaultCollection;
+const isSameItem = (a: CollectionItem, b: CollectionItem) =>
+ a.id === b.id && a.model === b.model;
+function setup({
+ items = defaultItems,
+ collection = defaultCollection,
+ selected = [],
+ onToggleSelected = jest.fn(),
+}: {
+ items?: CollectionItem[];
+ collection?: Collection;
+ selected?: CollectionItem[];
+ onToggleSelected?: OnToggleSelectedWithItem;
+} = {}) {
mockOnCopy.mockReset();
mockOnMove.mockReset();
@@ -69,6 +79,11 @@ function setup({
onMove={mockOnMove}
createBookmark={jest.fn()}
deleteBookmark={jest.fn()}
+ selected={selected}
+ getIsSelected={(item) =>
+ selected.some((selectedItem) => isSameItem(selectedItem, item))
+ }
+ onToggleSelected={onToggleSelected}
/>,
{
withDND: true,
@@ -111,4 +126,59 @@ describe("PinnedItemsGrid", () => {
"Model Qux",
]);
});
+
+ it("should make all cards selectable when an item is selected", async () => {
+ const onToggleSelected = jest.fn();
+
+ setup({
+ selected: [dashboardItem],
+ onToggleSelected,
+ });
+
+ const section = within(await screen.findByTestId("pinned-items"));
+ expect(section.getAllByRole("checkbox")).toHaveLength(defaultItems.length);
+ expect(
+ section.getByRole("checkbox", { name: dashboardItem.name }),
+ ).toBeChecked();
+ expect(
+ section.getByRole("checkbox", { name: metricItem.name }),
+ ).not.toBeChecked();
+
+ await userEvent.click(
+ section.getByRole("checkbox", { name: metricItem.name }),
+ );
+
+ expect(onToggleSelected).toHaveBeenCalledWith(metricItem);
+ });
+
+ it("should keep cards as links in a read-only collection", async () => {
+ setup({
+ collection: createMockCollection({
+ ...defaultCollection,
+ can_write: false,
+ }),
+ selected: [dashboardItem],
+ onToggleSelected: jest.fn(),
+ });
+
+ await screen.findByTestId("pinned-items");
+ expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+ expect(screen.getAllByRole("link")).toHaveLength(defaultItems.length);
+ });
+
+ it("should keep cards as links when selection props are omitted", async () => {
+ setup();
+
+ await screen.findByTestId("pinned-items");
+ expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+ expect(screen.getAllByRole("link")).toHaveLength(defaultItems.length);
+ });
+
+ it("should keep cards as links when the selection is empty", async () => {
+ setup({ selected: [], onToggleSelected: jest.fn() });
+
+ await screen.findByTestId("pinned-items");
+ expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+ expect(screen.getAllByRole("link")).toHaveLength(defaultItems.length);
+ });
});
diff --git a/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.module.css b/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.module.css
index 254868e60b3..1709b7b5003 100644
--- a/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.module.css
+++ b/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.module.css
@@ -5,6 +5,15 @@
.card {
cursor: pointer;
box-shadow: none;
+
+ &.selectable:hover {
+ border-color: var(--mb-color-core-brand);
+ }
+
+ &.selected {
+ border-color: var(--mb-color-core-brand);
+ background-color: var(--mb-color-background_surface-brand-subtle);
+ }
}
.skeletonCard {
@@ -61,3 +70,8 @@
.card:hover .actions {
visibility: visible;
}
+
+.selectCheckbox {
+ flex: 0 0 auto;
+ padding-inline: 2px;
+}
diff --git a/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.tsx b/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.tsx
index 3861f2b99dd..ca1e213cf38 100644
--- a/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.tsx
+++ b/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.tsx
@@ -1,9 +1,12 @@
+import cx from "classnames";
+import { type FocusEvent, useState } from "react";
import { t } from "ttag";
import { ActionMenu } from "metabase/common/collections/components/ActionMenu";
import type {
CreateBookmark,
DeleteBookmark,
+ OnToggleSelectedWithItem,
} from "metabase/common/collections/types";
import { EntityIcon } from "metabase/common/components/EntityIcon";
import { EventSandbox } from "metabase/common/components/EventSandbox";
@@ -11,7 +14,7 @@ import { Link } from "metabase/common/components/Link";
import { MarkdownPreview } from "metabase/common/components/MarkdownPreview";
import { useGetIcon } from "metabase/hooks/use-icon";
import { PLUGIN_MODERATION } from "metabase/plugins";
-import { Box, Card, Ellipsified, Group } from "metabase/ui";
+import { Box, Card, Checkbox, Ellipsified, Group } from "metabase/ui";
import { modelToUrl } from "metabase/urls";
import type Database from "metabase-lib/v1/metadata/Database";
import type {
@@ -54,6 +57,9 @@ export type CompactPinnedItemCardProps = {
onCopy?: (items: CollectionItem[]) => void;
onMove?: (items: CollectionItem[]) => void;
onClick?: () => void;
+ isSelectMode?: boolean;
+ isSelected?: boolean;
+ onToggleSelected?: OnToggleSelectedWithItem;
};
const isCollectionItem = (
@@ -72,6 +78,9 @@ export function CompactPinnedItemCard({
onCopy,
onMove,
onClick,
+ isSelectMode,
+ isSelected,
+ onToggleSelected,
}: CompactPinnedItemCardProps) {
const getIcon = useGetIcon();
const icon = getIcon({
@@ -84,59 +93,141 @@ export function CompactPinnedItemCard({
const hasActionHandlers = Boolean(
onCopy || onMove || createBookmark || deleteBookmark || collection,
);
+ const toggleSelected =
+ onToggleSelected && isCollectionItem(item)
+ ? () => onToggleSelected(item)
+ : undefined;
+ const handleToggleSelected = isSelectMode ? toggleSelected : undefined;
+ const showAsSelected = handleToggleSelected != null && Boolean(isSelected);
+ const [isHoveredOrFocused, setIsHoveredOrFocused] = useState(false);
+ const showCheckbox =
+ handleToggleSelected != null && (showAsSelected || isHoveredOrFocused);
+ const highlightProps = toggleSelected
+ ? {
+ onMouseEnter: () => setIsHoveredOrFocused(true),
+ onMouseLeave: () => setIsHoveredOrFocused(false),
+ onFocus: (event: FocusEvent) => {
+ if (event.target === event.currentTarget) {
+ setIsHoveredOrFocused(true);
+ }
+ },
+ onBlur: (event: FocusEvent) => {
+ if (event.target === event.currentTarget) {
+ setIsHoveredOrFocused(false);
+ }
+ },
+ }
+ : {};
- return (
- <Link className={S.link} to={modelToUrl(item)} onClick={onClick}>
- <Card className={S.card} h="5rem" p={0} pos="relative" withBorder>
- <div className={S.body}>
+ const card = (
+ <Card
+ className={cx(S.card, {
+ [S.selectable]: handleToggleSelected != null,
+ [S.selected]: showAsSelected,
+ })}
+ data-testid="pinned-item-card"
+ h="5rem"
+ p={0}
+ pos="relative"
+ withBorder
+ >
+ <Box className={S.body}>
+ {showCheckbox ? (
+ <Checkbox
+ aria-hidden
+ checked={showAsSelected}
+ className={S.selectCheckbox}
+ data-testid="pinned-item-checkbox"
+ readOnly
+ size="sm"
+ style={{ pointerEvents: "none" }}
+ tabIndex={-1}
+ />
+ ) : (
<EntityIcon
{...icon}
className={S.icon}
size="1.25rem"
color="core-brand"
/>
- <div className={S.content}>
- <Group className={S.titleRow} gap="sm" miw={0} wrap="nowrap">
- <Ellipsified
- fw="bold"
- fz="md"
- lh="1rem"
- tooltipProps={{ maw: TOOLTIP_MAX_WIDTH, position: "bottom" }}
- >
- {item.name}
- </Ellipsified>
- <PLUGIN_MODERATION.ModerationStatusIcon
- status={item.moderated_status}
- filled
- size={14}
- />
- </Group>
- <MarkdownPreview
- className={S.description}
- tooltipMaxWidth={TOOLTIP_MAX_WIDTH}
- >
- {description}
- </MarkdownPreview>
- </div>
- </div>
- {actionMenuItem && hasActionHandlers && (
- <Box className={S.actions}>
- {/* Used within a `<Link>`, so we must prevent events from triggering the link */}
- <EventSandbox preventDefault sandboxedEvents={["onClick"]}>
- <ActionMenu
- item={actionMenuItem}
- collection={collection}
- databases={databases}
- bookmarks={bookmarks}
- createBookmark={createBookmark}
- deleteBookmark={deleteBookmark}
- onCopy={onCopy}
- onMove={onMove}
- />
- </EventSandbox>
- </Box>
)}
- </Card>
+ <Box className={S.content}>
+ <Group className={S.titleRow} gap="sm" miw={0} wrap="nowrap">
+ <Ellipsified
+ fw="bold"
+ fz="md"
+ lh="1rem"
+ tooltipProps={{ maw: TOOLTIP_MAX_WIDTH, position: "bottom" }}
+ >
+ {item.name}
+ </Ellipsified>
+ <PLUGIN_MODERATION.ModerationStatusIcon
+ status={item.moderated_status}
+ filled
+ size={14}
+ />
+ </Group>
+ <MarkdownPreview
+ className={S.description}
+ tooltipMaxWidth={TOOLTIP_MAX_WIDTH}
+ >
+ {description}
+ </MarkdownPreview>
+ </Box>
+ </Box>
+ {actionMenuItem && hasActionHandlers && (
+ <Box className={S.actions}>
+ {/* Used within a `<Link>`, so we must prevent events from triggering the link */}
+ <EventSandbox preventDefault sandboxedEvents={["onClick"]}>
+ <ActionMenu
+ item={actionMenuItem}
+ collection={collection}
+ databases={databases}
+ bookmarks={bookmarks}
+ createBookmark={createBookmark}
+ deleteBookmark={deleteBookmark}
+ onCopy={onCopy}
+ onMove={onMove}
+ />
+ </EventSandbox>
+ </Box>
+ )}
+ </Card>
+ );
+
+ if (handleToggleSelected) {
+ return (
+ <Box
+ {...highlightProps}
+ aria-checked={showAsSelected}
+ aria-label={item.name}
+ className={S.link}
+ role="checkbox"
+ tabIndex={0}
+ onClick={handleToggleSelected}
+ onKeyDown={(event) => {
+ if (event.target !== event.currentTarget) {
+ return;
+ }
+ if (event.key === " " || event.key === "Enter") {
+ event.preventDefault();
+ handleToggleSelected();
+ }
+ }}
+ >
+ {card}
+ </Box>
+ );
+ }
+
+ return (
+ <Link
+ {...highlightProps}
+ className={S.link}
+ to={modelToUrl(item)}
+ onClick={onClick}
+ >
+ {card}
</Link>
);
}
diff --git a/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.unit.spec.tsx b/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.unit.spec.tsx
index 8f3a1bea9fa..aaa1440871e 100644
--- a/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.unit.spec.tsx
+++ b/frontend/src/metabase/common/collections/components/CompactPinnedItemCard/CompactPinnedItemCard.unit.spec.tsx
@@ -1,13 +1,23 @@
import userEvent from "@testing-library/user-event";
+import { useState } from "react";
import {
+ act,
+ fireEvent,
+ queryIcon,
renderWithProviders,
screen,
getIcon as testGetIcon,
} from "__support__/ui";
+import type { OnToggleSelectedWithItem } from "metabase/common/collections/types";
import { modelIconMap } from "metabase/common/utils/icon";
import { Route } from "metabase/router";
-import type { CollectionItemModel } from "metabase-types/api";
+import type {
+ Collection,
+ CollectionItem,
+ CollectionItemModel,
+ RecentCollectionItem,
+} from "metabase-types/api";
import {
createMockCollection,
createMockCollectionItem,
@@ -31,7 +41,46 @@ const defaultItem = createMockCollectionItem({
collection_position: 1,
});
-function setup({ item = defaultItem, collection = defaultCollection } = {}) {
+function HoverStateHarness() {
+ const [isSelectMode, setIsSelectMode] = useState(true);
+ const [isSelected, setIsSelected] = useState(false);
+
+ const handleToggleSelected = () => {
+ if (isSelected) {
+ setIsSelected(false);
+ setIsSelectMode(false);
+ } else {
+ setIsSelected(true);
+ }
+ };
+
+ return (
+ <>
+ <button onClick={() => setIsSelectMode(true)}>Enter select mode</button>
+ <CompactPinnedItemCard
+ item={defaultItem}
+ collection={defaultCollection}
+ isSelectMode={isSelectMode}
+ isSelected={isSelected}
+ onToggleSelected={handleToggleSelected}
+ />
+ </>
+ );
+}
+
+function setup({
+ item = defaultItem,
+ collection = defaultCollection,
+ isSelectMode,
+ isSelected,
+ onToggleSelected,
+}: {
+ item?: CollectionItem | RecentCollectionItem;
+ collection?: Collection;
+ isSelectMode?: boolean;
+ isSelected?: boolean;
+ onToggleSelected?: OnToggleSelectedWithItem;
+} = {}) {
return renderWithProviders(
<Route
path="/"
@@ -43,6 +92,9 @@ function setup({ item = defaultItem, collection = defaultCollection } = {}) {
onMove={jest.fn()}
createBookmark={jest.fn()}
deleteBookmark={jest.fn()}
+ isSelectMode={isSelectMode}
+ isSelected={isSelected}
+ onToggleSelected={onToggleSelected}
/>
}
/>,
@@ -92,6 +144,221 @@ describe("CompactPinnedItemCard", () => {
expect(await screen.findByText("Unpin")).toBeInTheDocument();
});
+ describe("select mode", () => {
+ it("should render a selected card as a checkbox without a model icon or link", () => {
+ setup({
+ isSelectMode: true,
+ isSelected: true,
+ onToggleSelected: jest.fn(),
+ });
+
+ expect(
+ screen.getByRole("checkbox", { name: defaultItem.name }),
+ ).toBeChecked();
+ expect(screen.queryByRole("link")).not.toBeInTheDocument();
+ expect(
+ queryIcon(modelIconMap[defaultItem.model]),
+ ).not.toBeInTheDocument();
+ expect(screen.getByTestId("pinned-item-card")).toBeInTheDocument();
+ });
+
+ it("should keep the model icon on an unselected card", () => {
+ setup({
+ isSelectMode: true,
+ isSelected: false,
+ onToggleSelected: jest.fn(),
+ });
+
+ expect(
+ screen.getByRole("checkbox", { name: defaultItem.name }),
+ ).not.toBeChecked();
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+ });
+
+ it("should swap the icon for an unchecked checkbox while hovering an unselected card", async () => {
+ setup({
+ isSelectMode: true,
+ isSelected: false,
+ onToggleSelected: jest.fn(),
+ });
+ const card = screen.getByRole("checkbox", { name: defaultItem.name });
+
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+
+ await userEvent.hover(card);
+
+ expect(
+ queryIcon(modelIconMap[defaultItem.model]),
+ ).not.toBeInTheDocument();
+ expect(screen.getByTestId("pinned-item-checkbox")).not.toBeChecked();
+ expect(card).not.toBeChecked();
+
+ await userEvent.unhover(card);
+
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+ });
+
+ it("should show a checked checkbox while hovering a selected card", async () => {
+ setup({
+ isSelectMode: true,
+ isSelected: true,
+ onToggleSelected: jest.fn(),
+ });
+ const card = screen.getByRole("checkbox", { name: defaultItem.name });
+
+ expect(screen.getByTestId("pinned-item-checkbox")).toBeChecked();
+ expect(
+ queryIcon(modelIconMap[defaultItem.model]),
+ ).not.toBeInTheDocument();
+
+ await userEvent.hover(card);
+
+ expect(screen.getByTestId("pinned-item-checkbox")).toBeChecked();
+ expect(
+ queryIcon(modelIconMap[defaultItem.model]),
+ ).not.toBeInTheDocument();
+
+ await userEvent.unhover(card);
+
+ expect(screen.getByTestId("pinned-item-checkbox")).toBeChecked();
+ });
+
+ it("should swap the icon for a checkbox when the card receives keyboard focus", () => {
+ setup({
+ isSelectMode: true,
+ isSelected: false,
+ onToggleSelected: jest.fn(),
+ });
+ const card = screen.getByRole("checkbox", { name: defaultItem.name });
+
+ act(() => card.focus());
+
+ expect(
+ queryIcon(modelIconMap[defaultItem.model]),
+ ).not.toBeInTheDocument();
+ expect(screen.getByTestId("pinned-item-checkbox")).toBeInTheDocument();
+
+ fireEvent.blur(card);
+
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+ });
+
+ it("should keep the model icon when focusing the action menu", () => {
+ setup({
+ isSelectMode: true,
+ isSelected: false,
+ onToggleSelected: jest.fn(),
+ });
+
+ fireEvent.focus(screen.getByRole("button", { name: "Actions" }));
+
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+ });
+
+ it("should not swap the icon on hover outside select mode", async () => {
+ setup();
+ const card = screen.getByTestId("pinned-item-card");
+
+ await userEvent.hover(card);
+
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+ expect(
+ screen.queryByTestId("pinned-item-checkbox"),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should clear hover state after leaving a card outside select mode (UXW-4996)", async () => {
+ renderWithProviders(<Route path="/" element={<HoverStateHarness />} />, {
+ withRouter: true,
+ });
+ const card = screen.getByRole("checkbox", { name: defaultItem.name });
+
+ fireEvent.mouseEnter(card);
+ expect(screen.getByTestId("pinned-item-checkbox")).toBeInTheDocument();
+
+ fireEvent.click(card);
+ fireEvent.click(card);
+ fireEvent.mouseLeave(screen.getByRole("link"));
+ await userEvent.click(
+ screen.getByRole("button", { name: "Enter select mode" }),
+ );
+
+ expect(testGetIcon(modelIconMap[defaultItem.model])).toBeInTheDocument();
+ expect(
+ screen.queryByTestId("pinned-item-checkbox"),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should toggle the item exactly once when the card body is clicked", async () => {
+ const onToggleSelected = jest.fn();
+ setup({ isSelectMode: true, onToggleSelected });
+
+ await userEvent.click(screen.getByText(defaultItem.name));
+
+ expect(onToggleSelected).toHaveBeenCalledTimes(1);
+ expect(onToggleSelected).toHaveBeenCalledWith(defaultItem);
+ expect(screen.queryByRole("link")).not.toBeInTheDocument();
+ });
+
+ it("should toggle the item with the Space key", async () => {
+ const onToggleSelected = jest.fn();
+ setup({ isSelectMode: true, onToggleSelected });
+ const card = screen.getByRole("checkbox", { name: defaultItem.name });
+
+ act(() => card.focus());
+ await userEvent.keyboard(" ");
+
+ expect(onToggleSelected).toHaveBeenCalledTimes(1);
+ expect(onToggleSelected).toHaveBeenCalledWith(defaultItem);
+ });
+
+ it("should open the action menu without toggling the item", async () => {
+ const onToggleSelected = jest.fn();
+ setup({ isSelectMode: true, onToggleSelected });
+
+ await userEvent.click(testGetIcon("ellipsis"));
+
+ expect(await screen.findByText("Unpin")).toBeInTheDocument();
+ expect(onToggleSelected).not.toHaveBeenCalled();
+ });
+
+ it("should open the action menu with the keyboard without toggling the item", async () => {
+ const onToggleSelected = jest.fn();
+ setup({ isSelectMode: true, onToggleSelected });
+
+ screen.getByRole("button", { name: "Actions" }).focus();
+ await userEvent.keyboard("{Enter}");
+
+ expect(await screen.findByText("Unpin")).toBeInTheDocument();
+ expect(onToggleSelected).not.toHaveBeenCalled();
+ });
+
+ it("should render a link when selection props are omitted", () => {
+ setup();
+
+ expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+ expect(screen.getByRole("link")).toBeInTheDocument();
+ expect(screen.getByTestId("pinned-item-card")).toBeInTheDocument();
+ });
+
+ it("should keep recent items as links", () => {
+ const recentItem = createMockRecentCollectionItem({
+ id: 7,
+ model: "dataset",
+ name: "Recent model",
+ });
+
+ setup({
+ item: recentItem,
+ isSelectMode: true,
+ onToggleSelected: jest.fn(),
+ });
+
+ expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+ expect(screen.getByRole("link")).toBeInTheDocument();
+ });
+ });
+
describe("recent items", () => {
const recentModel = createMockRecentCollectionItem({
id: 7,
diff --git a/frontend/src/metabase/common/hooks/use-list-select.ts b/frontend/src/metabase/common/hooks/use-list-select.ts
index ae1985a468e..37e77ec08ca 100644
--- a/frontend/src/metabase/common/hooks/use-list-select.ts
+++ b/frontend/src/metabase/common/hooks/use-list-select.ts
@@ -1,4 +1,4 @@
-import { useCallback, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
export type UseListSelectReturnValue<T> = {
clear: () => void;
@@ -11,45 +11,47 @@ export type UseListSelectReturnValue<T> = {
export function useListSelect<T>(
keyFn: (item: T) => string,
): UseListSelectReturnValue<T> {
- const [selectedKeys, setSelectedKeys] = useState<Set<string>>(new Set());
- const [selected, setSelected] = useState<T[]>([]);
+ const [selectedByKey, setSelectedByKey] = useState<ReadonlyMap<string, T>>(
+ new Map(),
+ );
const getIsSelected = useCallback(
- (item: T) => selectedKeys.has(keyFn(item)),
- [keyFn, selectedKeys],
+ (item: T) => selectedByKey.has(keyFn(item)),
+ [keyFn, selectedByKey],
);
const selectOnlyTheseItems = useCallback(
(items: T[]) => {
- const newSelected = items;
- const newSelectedKeys = new Set(newSelected.map(keyFn));
-
- setSelectedKeys(newSelectedKeys);
- setSelected(newSelected);
+ setSelectedByKey(new Map(items.map((item) => [keyFn(item), item])));
},
[keyFn],
);
const toggleItem = useCallback(
- (itemBeingToggled: T) => {
- const isItemSelected = getIsSelected(itemBeingToggled);
-
- const newSelected = isItemSelected
- ? selected.filter((item) => keyFn(item) !== keyFn(itemBeingToggled))
- : [...selected, itemBeingToggled];
- const newSelectedKeys = new Set(newSelected.map(keyFn));
-
- setSelectedKeys(newSelectedKeys);
- setSelected(newSelected);
+ (item: T) => {
+ setSelectedByKey((previous) => {
+ const key = keyFn(item);
+ const next = new Map(previous);
+ if (next.has(key)) {
+ next.delete(key);
+ } else {
+ next.set(key, item);
+ }
+ return next;
+ });
},
- [keyFn, selected, getIsSelected],
+ [keyFn],
);
const clear = useCallback(() => {
- setSelectedKeys(new Set());
- setSelected([]);
+ setSelectedByKey(new Map());
}, []);
+ const selected = useMemo(
+ () => Array.from(selectedByKey.values()),
+ [selectedByKey],
+ );
+
return {
clear,
getIsSelected,
diff --git a/frontend/src/metabase/common/hooks/use-list-select.unit.spec.ts b/frontend/src/metabase/common/hooks/use-list-select.unit.spec.ts
index 93dde2b8af2..b418430a8aa 100644
--- a/frontend/src/metabase/common/hooks/use-list-select.unit.spec.ts
+++ b/frontend/src/metabase/common/hooks/use-list-select.unit.spec.ts
@@ -88,4 +88,56 @@ describe("useListSelect", () => {
act(() => result.current.clear());
expect(result.current.selected).toHaveLength(0);
});
+
+ it("should preserve all items toggled in the same batch", () => {
+ const result = setup();
+
+ act(() => {
+ result.current.toggleItem(OBJECT_LIST[0]);
+ result.current.toggleItem(OBJECT_LIST[1]);
+ });
+
+ expect(result.current.selected).toEqual([OBJECT_LIST[0], OBJECT_LIST[1]]);
+ });
+
+ it("should toggle matching keys across distinct objects", () => {
+ const result = setup();
+ const cardCopy = { id: 1, name: "first" };
+ const rowCopy = { id: 1, name: "first" };
+
+ act(() => result.current.toggleItem(cardCopy));
+ expect(result.current.getIsSelected(rowCopy)).toBeTruthy();
+
+ act(() => result.current.toggleItem(rowCopy));
+ expect(result.current.selected).toHaveLength(0);
+ expect(result.current.getIsSelected(cardCopy)).toBeFalsy();
+ });
+
+ it("should deduplicate selectOnlyTheseItems input by key", () => {
+ const result = setup();
+
+ act(() =>
+ result.current.selectOnlyTheseItems([
+ { ...OBJECT_LIST[0] },
+ { ...OBJECT_LIST[0] },
+ ]),
+ );
+
+ expect(result.current.selected).toHaveLength(1);
+ });
+
+ it("should clear items after mixed selection operations", () => {
+ const result = setup();
+
+ act(() =>
+ result.current.selectOnlyTheseItems([OBJECT_LIST[0], OBJECT_LIST[1]]),
+ );
+ act(() => result.current.toggleItem(OBJECT_LIST[2]));
+ act(() => result.current.clear());
+
+ expect(result.current.selected).toHaveLength(0);
+ OBJECT_LIST.forEach((item) => {
+ expect(result.current.getIsSelected(item)).toBeFalsy();
+ });
+ });
});