Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(tags): drag sidebar tags onto list rows (#7057)

Wolf Mermelstein94876630d69a
diff --git a/apps/web/AGENTS.md b/apps/web/AGENTS.md
index b6e784eb20..44cc0bd295 100644
--- a/apps/web/AGENTS.md
+++ b/apps/web/AGENTS.md
@@ -683,3 +683,11 @@ See the [download walkthrough](../../docs/agent-guide/files.md#downloading-files
- Reuse `CreateMenuItem` for explanatory New menu entries: original icons, a title, and muted wrapping descriptions, preserving the existing `ViewCreateButton` trigger and each action's feature gates.
- Keep transient toasts in their bounded stack and persistent prompts/reminders in separate regions; preserve keyboard dismissal, full mobile descriptions, and remaining-time pause on hover/focus.
+
+### Sidebar tag dragging
+
+Email and Calls sidebar tags can be dragged onto taggable desktop list rows.
+Keep existing tags and apply to the selected rows when the drop row is selected.
+Use the shared scoped drag helpers and overlayIcon for the tag chip.
+The backend-free browser regression is
+`bunx playwright test --config src/features/property/tags/browser-test/playwright.config.ts`.
diff --git a/apps/web/src/features/property/tags/DroppedTagApplier.tsx b/apps/web/src/features/property/tags/DroppedTagApplier.tsx
new file mode 100644
index 0000000000..f4503201a5
--- /dev/null
+++ b/apps/web/src/features/property/tags/DroppedTagApplier.tsx
@@ -0,0 +1,44 @@
+import { fireAndForget } from '@core/util/fireAndForget';
+import type { EntityData } from '@entity/types/entity';
+import { Telemetry } from '@macro-inc/observability';
+import type { TreeTag } from './core/tag-tree';
+import { tagEntityType } from './entityTagging';
+import { useSoupDocTags } from './useDocTags';
+
+/**
+ * Applies a dropped tag to each entity, keeping their existing tags, then
+ * calls `onDone`. Mount it for the lifetime of one drop.
+ */
+export function DroppedTagApplier(props: {
+ tag: TreeTag;
+ entities: EntityData[];
+ onDone: () => void;
+}) {
+ const settle = () =>
+ Telemetry.span('tag.drop_apply', async (span) => {
+ span.setAttr('tag.id', props.tag.id);
+ const applications = props.entities.flatMap((entity) => {
+ const entityType = tagEntityType(entity);
+ if (!entityType) return [];
+ const docTags = useSoupDocTags(entity.id, entityType, () =>
+ 'properties' in entity ? entity.properties : undefined
+ );
+ return [docTags.applyTag(props.tag.scope, props.tag.id)];
+ });
+ span.setAttr('tag.entity_count', applications.length);
+ const results = await Promise.allSettled(applications);
+ let failures = 0;
+ for (const result of results) {
+ if (result.status === 'rejected') {
+ failures++;
+ Telemetry.error(result.reason, { surface: 'tag-drop' });
+ }
+ }
+ span.setAttr('tag.failure_count', failures);
+ if (failures > 0) span.error('Tag application failed');
+ props.onDone();
+ });
+ fireAndForget(settle(), 'tag-drop');
+
+ return null;
+}
diff --git a/apps/web/src/features/property/tags/browser-test/playwright.config.ts b/apps/web/src/features/property/tags/browser-test/playwright.config.ts
new file mode 100644
index 0000000000..04d1fe80e2
--- /dev/null
+++ b/apps/web/src/features/property/tags/browser-test/playwright.config.ts
@@ -0,0 +1,23 @@
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from '@playwright/test';
+
+const port = process.env.TAG_DRAG_TEST_PORT ?? '3500';
+export default defineConfig({
+ testDir: fileURLToPath(new URL('.', import.meta.url)),
+ testMatch: '*.browser.e2e.ts',
+ workers: 1,
+ timeout: 120_000,
+ use: {
+ baseURL: `http://localhost:${port}`,
+ launchOptions: {
+ executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
+ },
+ },
+ webServer: {
+ command: `MACRO_DEV_HTTPS=false bunx vite --port ${port} --strictPort`,
+ cwd: fileURLToPath(new URL('../../../../../', import.meta.url)),
+ url: `http://localhost:${port}/app/`,
+ reuseExistingServer: false,
+ timeout: 60_000,
+ },
+});
diff --git a/apps/web/src/features/property/tags/browser-test/tags.browser.e2e.ts b/apps/web/src/features/property/tags/browser-test/tags.browser.e2e.ts
new file mode 100644
index 0000000000..c58ec3b49b
--- /dev/null
+++ b/apps/web/src/features/property/tags/browser-test/tags.browser.e2e.ts
@@ -0,0 +1,34 @@
+import { expect, test } from '@playwright/test';
+
+test('a sidebar tag applies on drag and still filters on click', async ({
+ page,
+}) => {
+ await page.route('**/*', async (route) => {
+ if (new URL(route.request().url()).hostname === 'localhost')
+ await route.continue();
+ else await route.fulfill({ status: 401, body: '{}' });
+ });
+ await page.routeWebSocket('**/*', (socket) => socket.close());
+ await page.goto('/src/features/property/tags/browser-test/tags.html');
+ const tag = page.getByText('Urgent', { exact: true });
+ await expect(tag).toBeVisible({ timeout: 60_000 });
+ await tag.click();
+ await expect(page.getByLabel('Filter')).toHaveText('urgent');
+ const origin = await tag.boundingBox();
+ const row = page.getByTestId('row');
+ const destination = await row.boundingBox();
+ if (!origin || !destination) throw new Error('Drag bounds missing');
+ await page.mouse.move(
+ origin.x + origin.width / 2,
+ origin.y + origin.height / 2
+ );
+ await page.mouse.down();
+ await page.mouse.move(
+ destination.x + destination.width / 2,
+ destination.y + destination.height / 2,
+ { steps: 15 }
+ );
+ await expect(row).toHaveClass(/outline-2/);
+ await page.mouse.up();
+ await expect(page.getByLabel('Applied tags')).toHaveText('Existing, Urgent');
+});
diff --git a/apps/web/src/features/property/tags/browser-test/tags.html b/apps/web/src/features/property/tags/browser-test/tags.html
new file mode 100644
index 0000000000..6518603d6c
--- /dev/null
+++ b/apps/web/src/features/property/tags/browser-test/tags.html
@@ -0,0 +1 @@
+<!doctype html><html><head><meta charset="UTF-8"><title>Tag drag fixture</title></head><body><div id="root"></div><script type="module" src="./tags.tsx"></script></body></html>
diff --git a/apps/web/src/features/property/tags/browser-test/tags.tsx b/apps/web/src/features/property/tags/browser-test/tags.tsx
new file mode 100644
index 0000000000..7d2639fe4c
--- /dev/null
+++ b/apps/web/src/features/property/tags/browser-test/tags.tsx
@@ -0,0 +1,58 @@
+import '@app/index.css';
+import { ItemDndProvider } from '@components/app/ItemDragAndDrop';
+import { createSignal } from 'solid-js';
+import { render } from 'solid-js/web';
+import { TagTree } from '../components/tag-tree';
+import { buildTagTree } from '../core/tag-tree';
+import { createTagDropTarget } from '../tag-drag-and-drop';
+
+function Fixture() {
+ const [applied, setApplied] = createSignal<string[]>(['Existing']);
+ const [selected, setSelected] = createSignal('');
+ const target = createTagDropTarget({
+ onDropTag: (tag) =>
+ setApplied((tags) => [...new Set([...tags, tag.label])]),
+ });
+ const nodes = buildTagTree([
+ {
+ id: 'urgent',
+ label: 'Urgent',
+ color: 'red',
+ scope: 'user',
+ propertyDefinitionId: 'fixture-tags',
+ },
+ ]);
+ return (
+ <main class="flex gap-8 p-8">
+ <aside class="w-60">
+ <TagTree
+ nodes={nodes}
+ activeIds={[]}
+ isExpanded={() => true}
+ onToggle={() => {}}
+ onSelect={setSelected}
+ />
+ </aside>
+ <div
+ ref={(element) => target?.ref(element)}
+ data-testid="row"
+ class="w-80 p-8 border"
+ classList={{ 'outline-2': target?.isOver() }}
+ >
+ <p>Example email</p>
+ <output aria-label="Applied tags">{applied().join(', ')}</output>
+ </div>
+ <output aria-label="Filter">{selected()}</output>
+ </main>
+ );
+}
+const root = document.getElementById('root');
+if (!root) throw new Error('Fixture root missing');
+render(
+ () => (
+ <ItemDndProvider>
+ <Fixture />
+ </ItemDndProvider>
+ ),
+ root
+);
diff --git a/apps/web/src/features/property/tags/components/tag-tree.tsx b/apps/web/src/features/property/tags/components/tag-tree.tsx
index cb147d97eb..cb2a16c62b 100644
--- a/apps/web/src/features/property/tags/components/tag-tree.tsx
+++ b/apps/web/src/features/property/tags/components/tag-tree.tsx
@@ -2,6 +2,7 @@ import { ViewSidebar } from '@app/components/view-shell';
import { For, Show } from 'solid-js';
import type { TagTreeNode } from '../core/tag-tree';
import { TagDot } from '../TagDot';
+import { createTagDraggable } from '../tag-drag-and-drop';
import { BranchTagIcon } from './branch-tag-icon';
export function TagTree(props: {
@@ -18,27 +19,32 @@ export function TagTree(props: {
const open = () => props.isExpanded(node);
const active = () =>
Boolean(node.tag && props.activeIds.includes(node.tag.id));
+ const draggable = node.tag ? createTagDraggable(node.tag) : undefined;
return (
<li class="min-w-0">
- <ViewSidebar.TreeItem
- active={active()}
- expanded={node.children.length > 0 ? open() : undefined}
- label={node.path}
- onToggle={() => props.onToggle(node)}
- onClick={() =>
- node.tag ? props.onSelect(node.tag.id) : props.onToggle(node)
- }
- >
- <ViewSidebar.Icon>
- <Show
- when={node.children.length > 0}
- fallback={<TagDot color={node.tag?.color} />}
- >
- <BranchTagIcon node={node} />
- </Show>
- </ViewSidebar.Icon>
- <span class="truncate">{node.name}</span>
- </ViewSidebar.TreeItem>
+ <div ref={(element) => draggable?.(element)}>
+ <ViewSidebar.TreeItem
+ active={active()}
+ expanded={node.children.length > 0 ? open() : undefined}
+ label={node.path}
+ onToggle={() => props.onToggle(node)}
+ onClick={() =>
+ node.tag
+ ? props.onSelect(node.tag.id)
+ : props.onToggle(node)
+ }
+ >
+ <ViewSidebar.Icon>
+ <Show
+ when={node.children.length > 0}
+ fallback={<TagDot color={node.tag?.color} />}
+ >
+ <BranchTagIcon node={node} />
+ </Show>
+ </ViewSidebar.Icon>
+ <span class="truncate">{node.name}</span>
+ </ViewSidebar.TreeItem>
+ </div>
<ViewSidebar.Branch open={open() && node.children.length > 0}>
<TagTree {...props} nodes={node.children} />
</ViewSidebar.Branch>
diff --git a/apps/web/src/features/property/tags/tag-drag-and-drop.test.tsx b/apps/web/src/features/property/tags/tag-drag-and-drop.test.tsx
new file mode 100644
index 0000000000..9050e9e5e5
--- /dev/null
+++ b/apps/web/src/features/property/tags/tag-drag-and-drop.test.tsx
@@ -0,0 +1,127 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { createPointerCollisionDetector } from '@components/app/pointer-collision';
+import { cleanup, fireEvent, render } from '@solidjs/testing-library';
+import {
+ createDroppable,
+ DragDropProvider,
+ DragDropSensors,
+} from '@thisbeyond/solid-dnd';
+import { createSignal } from 'solid-js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { TreeTag } from './core/tag-tree';
+import { createTagDraggable, createTagDropTarget } from './tag-drag-and-drop';
+
+const tag: TreeTag = {
+ id: 'urgent',
+ label: 'Urgent',
+ color: 'red',
+ scope: 'user',
+ propertyDefinitionId: 'personal-definition',
+};
+
+function setup(options: { disabled?: () => boolean } = {}) {
+ const onDropTag = vi.fn();
+ const onEntityDrop = vi.fn();
+ let hovered: Element | null = null;
+ const collision = createPointerCollisionDetector(
+ () => ({ x: 0, y: 0 }),
+ () => hovered
+ );
+
+ function Tag() {
+ const draggable = createTagDraggable(tag);
+ return (
+ <div ref={(element) => draggable?.(element)} data-testid="tag">
+ Urgent
+ </div>
+ );
+ }
+
+ function Row() {
+ const target = createTagDropTarget({
+ onDropTag,
+ disabled: options.disabled,
+ });
+ return (
+ <div ref={(element) => target?.ref(element)} data-testid="row">
+ <span data-testid="row-child">A task</span>
+ </div>
+ );
+ }
+
+ function EntityDropZone() {
+ const droppable = createDroppable('entity-zone');
+ return <div ref={droppable.ref} data-testid="entity-zone" />;
+ }
+
+ const view = render(() => (
+ <DragDropProvider
+ collisionDetector={collision}
+ onDragEnd={({ droppable }) => {
+ if (droppable?.id === 'entity-zone') onEntityDrop();
+ }}
+ >
+ <DragDropSensors />
+ <Tag />
+ <Row />
+ <EntityDropZone />
+ </DragDropProvider>
+ ));
+
+ const dragTagOnto = (testId: string) => {
+ hovered = view.getByTestId(testId);
+ fireEvent.mouseDown(view.getByTestId('tag'), {
+ button: 0,
+ clientX: 0,
+ clientY: 0,
+ });
+ fireEvent.mouseMove(document, { clientX: 40, clientY: 0 });
+ fireEvent.mouseMove(document, { clientX: 50, clientY: 0 });
+ fireEvent.mouseUp(document, { button: 0 });
+ };
+
+ return { ...view, onDropTag, onEntityDrop, dragTagOnto };
+}
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe('tag drag and drop', () => {
+ it('hands the dropped tag to the row under the pointer', () => {
+ const { dragTagOnto, onDropTag } = setup();
+ dragTagOnto('row-child');
+ expect(onDropTag).toHaveBeenCalledOnce();
+ expect(onDropTag).toHaveBeenCalledWith(tag);
+ });
+
+ it('ignores rows that cannot take tags', () => {
+ const [disabled] = createSignal(true);
+ const { dragTagOnto, onDropTag } = setup({ disabled });
+ dragTagOnto('row');
+ expect(onDropTag).not.toHaveBeenCalled();
+ });
+
+ it('never lands on drop zones meant for entities', () => {
+ const { dragTagOnto, onDropTag, onEntityDrop } = setup();
+ dragTagOnto('entity-zone');
+ expect(onEntityDrop).not.toHaveBeenCalled();
+ expect(onDropTag).not.toHaveBeenCalled();
+ });
+
+ it('renders plain rows outside a drag provider', () => {
+ function Standalone() {
+ const draggable = createTagDraggable(tag);
+ const target = createTagDropTarget({ onDropTag: () => {} });
+ return (
+ <div>{String(draggable === undefined && target === undefined)}</div>
+ );
+ }
+ const { container } = render(() => <Standalone />);
+ expect(container.textContent).toBe('true');
+ });
+});
diff --git a/apps/web/src/features/property/tags/tag-drag-and-drop.tsx b/apps/web/src/features/property/tags/tag-drag-and-drop.tsx
new file mode 100644
index 0000000000..2863f6c47c
--- /dev/null
+++ b/apps/web/src/features/property/tags/tag-drag-and-drop.tsx
@@ -0,0 +1,90 @@
+import {
+ createDraggable,
+ createDroppable,
+ useDragDropContext,
+} from '@thisbeyond/solid-dnd';
+import { type Accessor, createUniqueId, type JSXElement } from 'solid-js';
+import type { TreeTag } from './core/tag-tree';
+import { TagDot } from './TagDot';
+
+/**
+ * Pointer collisions only match a droppable in the draggable's scope, so tag
+ * drags never land on entity drop zones and entity drags skip tag targets.
+ */
+const TAG_DND_SCOPE = 'entity-tag';
+
+export type TagDragData = {
+ dragType: 'tag';
+ dndScope: typeof TAG_DND_SCOPE;
+ name: string;
+ overlayIcon: () => JSXElement;
+ color?: string;
+};
+
+type TagDropData = {
+ dragType: 'tag-target';
+ dndScope: typeof TAG_DND_SCOPE;
+ onDropTag: (tag: TreeTag) => void;
+ isDropTargetDisabled: () => boolean;
+};
+
+function isTagDropData(data: unknown): data is TagDropData {
+ return (
+ typeof data === 'object' &&
+ data !== null &&
+ 'dragType' in data &&
+ data.dragType === 'tag-target'
+ );
+}
+
+/**
+ * Makes a tag draggable onto any `createTagDropTarget` row. Returns undefined
+ * outside the app's DragDropProvider, where there is nothing to drop onto.
+ */
+export function createTagDraggable(
+ tag: TreeTag
+): ((element: HTMLElement) => void) | undefined {
+ const context = useDragDropContext();
+ if (!context) return undefined;
+
+ const id = `tag-drag:${createUniqueId()}`;
+ const draggable = createDraggable(id, {
+ dragType: 'tag',
+ dndScope: TAG_DND_SCOPE,
+ name: tag.label,
+ overlayIcon: () => <TagDot color={tag.color} />,
+ color: tag.color,
+ } satisfies TagDragData);
+
+ // Registered per draggable (not per target) so each drop applies once.
+ context[1].onDragEnd(({ draggable: dragged, droppable }) => {
+ if (dragged.id !== id || !droppable) return;
+ if (!isTagDropData(droppable.data)) return;
+ if (droppable.data.isDropTargetDisabled()) return;
+ droppable.data.onDropTag(tag);
+ });
+
+ return draggable;
+}
+
+/** Registers an element as a place to drop a dragged tag. */
+export function createTagDropTarget(options: {
+ onDropTag: (tag: TreeTag) => void;
+ disabled?: Accessor<boolean>;
+}):
+ | { ref: (element: HTMLElement) => void; isOver: Accessor<boolean> }
+ | undefined {
+ if (!useDragDropContext()) return undefined;
+
+ const droppable = createDroppable(`tag-drop:${createUniqueId()}`, {
+ dragType: 'tag-target',
+ dndScope: TAG_DND_SCOPE,
+ onDropTag: options.onDropTag,
+ isDropTargetDisabled: () => options.disabled?.() ?? false,
+ } satisfies TagDropData);
+
+ return {
+ ref: droppable.ref,
+ isOver: () => droppable.isActiveDroppable,
+ };
+}
diff --git a/apps/web/src/features/soup/SoupEntityContextMenu.tsx b/apps/web/src/features/soup/SoupEntityContextMenu.tsx
index 62456bc238..9ea054edf0 100644
--- a/apps/web/src/features/soup/SoupEntityContextMenu.tsx
+++ b/apps/web/src/features/soup/SoupEntityContextMenu.tsx
@@ -3,6 +3,7 @@ import type {
EntityActionNavigationHandler,
EntityActionViewContext,
} from '@app/features/next-soup/actions';
+import { makeAddTagAction } from '@app/features/next-soup/actions';
import type { MarkDoneDelegate } from '@app/features/next-soup/actions/mark-done-delegate';
import {
ContextMenuContent,
@@ -12,6 +13,9 @@ import { touchHandler } from '@core/directive/touchHandler';
import { isMobile } from '@core/mobile/isMobile';
import type { EntityData } from '@entity';
import { ContextMenu } from '@kobalte/core/context-menu';
+import type { TreeTag } from '@property/tags/core/tag-tree';
+import { DroppedTagApplier } from '@property/tags/DroppedTagApplier';
+import { createTagDropTarget } from '@property/tags/tag-drag-and-drop';
import { cn } from '@ui';
import {
type Accessor,
@@ -72,6 +76,22 @@ export const SoupEntityContextMenu: FlowComponent<
anchor: menuPosition,
});
+ const addTagAction = makeAddTagAction();
+ const canEditTags = () => addTagAction.canExecute(props.entity);
+ const [droppedTag, setDroppedTag] = createSignal<{
+ tag: TreeTag;
+ entities: EntityData[];
+ }>();
+ // Dropping onto a selected row tags the whole selection, like the menu.
+ const tagDropTarget = createTagDropTarget({
+ disabled: () => isMobile() || !canEditTags(),
+ onDropTag: (tag) =>
+ setDroppedTag({
+ tag,
+ entities: menuEntities().filter(addTagAction.canExecute),
+ }),
+ });
+
return (
<Switch>
<Match when={isMobile()}>
@@ -102,7 +122,13 @@ export const SoupEntityContextMenu: FlowComponent<
<ContextMenu onOpenChange={props.onOpenChange}>
<ContextMenuTrigger
as={props.as}
- class={cn('h-full w-full group/cm-trigger', props.class)}
+ ref={(element: HTMLElement) => tagDropTarget?.ref(element)}
+ class={cn(
+ 'h-full w-full group/cm-trigger',
+ tagDropTarget?.isOver() &&
+ 'rounded-xl outline-2 -outline-offset-2 outline-accent',
+ props.class
+ )}
on:contextmenu={(event: MouseEvent) =>
setMenuPosition({ x: event.clientX, y: event.clientY })
}
@@ -130,6 +156,19 @@ export const SoupEntityContextMenu: FlowComponent<
</ContextMenu.Portal>
</ContextMenu>
<pickers.Pickers />
+ <Show when={droppedTag()} keyed>
+ {(drop) => (
+ <DroppedTagApplier
+ tag={drop.tag}
+ entities={drop.entities}
+ onDone={() =>
+ setDroppedTag((current) =>
+ current === drop ? undefined : current
+ )
+ }
+ />
+ )}
+ </Show>
</Match>
</Switch>
);
diff --git a/docs/agent-guide/email.md b/docs/agent-guide/email.md
index bf96548cb5..b72dafd708 100644
--- a/docs/agent-guide/email.md
+++ b/docs/agent-guide/email.md
@@ -1137,3 +1137,10 @@ Storage/schema failures that cannot prove preservation show recovery/update
instructions instead of repeatedly reopening potentially damaged storage.
Date-grouped email lists start directly with today's messages; Today is not shown as a leading group heading. Older date headings remain visible and ordering still uses the server's thread activity timestamp.
+
+## Dragging sidebar tags
+
+On desktop, drag a tag from the sidebar onto an email row. Its existing tags
+remain; dropping onto a selected row applies the tag to every taggable selected
+row. The dragged chip shows the tag color and name, and the target gets an outline.
+Clicking the tag still filters the list. Mobile uses the existing tag menu.