@dxos/plugin-kanban 0.8.4-main.9735255 → 0.8.4-main.abd8ff62ef

package/src/capabilities/undo-mappings.ts

@@ -0,0 +1,34 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+
+import { meta } from '#meta';
+import { KanbanOperation } from '#operations';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.UndoMapping, [
+      UndoMapping.make({
+        operation: KanbanOperation.DeleteCardField,
+        inverse: KanbanOperation.RestoreCardField,
+        deriveContext: (input, output) => ({
+          view: input.view,
+          field: output.field,
+          props: output.props,
+          index: output.index,
+        }),
+        message: ['card-field-deleted.label', { ns: meta.id }],
+      }),
+      UndoMapping.make({
+        operation: KanbanOperation.DeleteCard,
+        inverse: KanbanOperation.RestoreCard,
+        deriveContext: (_input, output) => ({
+          card: output.card,
+        }),
+        message: ['card-deleted.label', { ns: meta.id }],
+      }),
+    ]),
+  ),
+);

package/src/components/KanbanBoard/KanbanBoard.stories.tsx

@@ -0,0 +1,146 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom, RegistryContext } from '@effect-atom/atom-react';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useContext, useEffect, useMemo, useState } from 'react';
+
+import { Filter, JsonSchema, Obj, Query } from '@dxos/echo';
+import { type View } from '@dxos/echo';
+import { random } from '@dxos/random';
+import { withMosaic } from '@dxos/react-ui-mosaic/testing';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { ProjectionModel, ViewModel, createEchoChangeCallback } from '@dxos/schema';
+import { withRegistry } from '@dxos/storybook-utils';
+import { Organization } from '@dxos/types';
+
+import { createEchoChangeCallback as createKanbanChangeCallback } from '#hooks';
+import { KanbanCardTileSimple } from '#testing';
+import { translations } from '#translations';
+import { Kanban } from '#types';
+
+import { KanbanBoard } from './KanbanBoard';
+
+random.seed(1);
+
+const createOrg = () => ({
+  name: random.commerce.productName(),
+  description: random.lorem.sentence(),
+  image: random.image.url(),
+  website: random.internet.url(),
+  status: random.helpers.arrayElement(Organization.StatusOptions).id as Organization.Organization['status'],
+});
+
+/**
+ * In-memory Kanban board: View + ProjectionModel + Kanban + items, no plugin manager or Space.
+ * Similar to react-ui-kanban Kanban.stories.tsx.
+ */
+const DefaultStory = () => {
+  const registry = useContext(RegistryContext);
+  const items = useMemo(() => Atom.make<Obj.Unknown[]>([]), []);
+  const [state, setState] = useState<{
+    view: View.View;
+    kanban: Kanban.Kanban;
+    projection: ProjectionModel;
+    change: ReturnType<typeof createKanbanChangeCallback>;
+  }>();
+
+  useEffect(() => {
+    const view = ViewModel.make({
+      query: Query.select(Filter.typename(Organization.Organization.typename)),
+      jsonSchema: JsonSchema.toJsonSchema(Organization.Organization),
+      pivotFieldName: 'status',
+    });
+    const kanban = Kanban.make({ view });
+    const change = createKanbanChangeCallback(kanban);
+    const projection = new ProjectionModel({
+      registry,
+      view,
+      baseSchema: JsonSchema.toJsonSchema(Organization.Organization),
+      change: createEchoChangeCallback(view),
+    });
+    projection.normalizeView();
+
+    const statuses = Organization.StatusOptions.map((o) => o.id);
+    const initialItems = Array.from({ length: 12 }, () =>
+      Obj.make(Organization.Organization, {
+        ...createOrg(),
+        status: random.helpers.arrayElement(statuses) as Organization.Organization['status'],
+      }),
+    );
+
+    setState({ view, kanban, projection, change });
+    registry.set(items, initialItems);
+  }, [registry, items]);
+
+  const columnFieldPath =
+    state?.projection.tryGetFieldProjection(state.projection.getFieldId('status') ?? '')?.props.property ?? 'status';
+
+  const handleCardAdd = useCallback(
+    (columnValue: string | undefined) => {
+      if (!state || !columnFieldPath || !registry) {
+        return undefined;
+      }
+      const card = Obj.make(Organization.Organization, {
+        ...createOrg(),
+        ...(columnFieldPath ? { [columnFieldPath]: columnValue } : {}),
+      });
+      const current = registry.get(items) ?? [];
+      registry.set(items, [...current, card]);
+      return card.id;
+    },
+    [state, columnFieldPath, registry, items],
+  );
+
+  const handleCardRemove = useCallback(
+    (card: Obj.Unknown) => {
+      if (!registry) {
+        return;
+      }
+      const current = registry.get(items) ?? [];
+      registry.set(
+        items,
+        current.filter((i) => i.id !== card.id),
+      );
+    },
+    [registry, items],
+  );
+
+  if (!state) {
+    return <Loading />;
+  }
+
+  return (
+    <KanbanBoard.Root
+      kanban={state.kanban}
+      projection={state.projection}
+      items={items}
+      itemTile={KanbanCardTileSimple}
+      change={state.change}
+      onCardAdd={handleCardAdd}
+      onCardRemove={handleCardRemove}
+    >
+      <KanbanBoard.Content />
+    </KanbanBoard.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-kanban/components/KanbanBoard',
+  component: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' }), withMosaic(), withRegistry],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+/**
+ * In-memory board with Echo-shaped objects. No plugin manager, client, or Space.
+ */
+export const Default: Story = {};

package/src/components/KanbanBoard/KanbanBoard.tsx

@@ -0,0 +1,198 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Atom, RegistryContext } from '@effect-atom/atom-react';
+import { createContext } from '@radix-ui/react-context';
+import React, {
+  type ComponentPropsWithoutRef,
+  type ComponentType,
+  type PropsWithChildren,
+  useCallback,
+  useContext,
+  useMemo,
+} from 'react';
+
+import { Obj } from '@dxos/echo';
+import { useTranslation } from '@dxos/react-ui';
+import { Board, useBoard } from '@dxos/react-ui-mosaic';
+import type { ProjectionModel } from '@dxos/schema';
+import { composable, composableProps } from '@dxos/ui-theme';
+
+import { useKanbanBoardModel, useKanbanColumnEventHandler } from '#hooks';
+import { meta } from '#meta';
+import { type Kanban, type KanbanChangeCallback, UNCATEGORIZED_ATTRIBUTES, UNCATEGORIZED_VALUE } from '#types';
+
+import { KanbanCard, type KanbanCardProps } from './KanbanCard';
+import { KanbanColumn, type KanbanColumnProps } from './KanbanColumn';
+
+// TODO(burdon): Rename Kanban.
+
+//
+// Context
+//
+
+const KANBAN_BOARD_NAME = 'KanbanBoard.Context';
+
+/**
+ * Context value for the Kanban board.
+ * Items are Echo objects (Obj.Unknown).
+ */
+type KanbanBoardContextValue = {
+  kanbanId: string;
+  projection: ProjectionModel | undefined;
+  columnFieldPath: string | undefined;
+  change: KanbanChangeCallback<Obj.Unknown>;
+  pivotFieldId: string | undefined;
+  getPivotAttributes: (columnValue: string) => { title: string; color: string };
+  itemTile?: ComponentType<KanbanCardProps>; // TODO(burdon): Prop.
+  onCardAdd?: (columnValue: string | undefined) => string | undefined;
+  onCardRemove?: (card: Obj.Unknown) => void;
+};
+
+const [KanbanBoardContext, useKanbanBoard] = createContext<KanbanBoardContextValue>(KANBAN_BOARD_NAME, {
+  kanbanId: 'never',
+  projection: undefined,
+  columnFieldPath: undefined,
+  change: { kanban: () => {}, setItemField: () => {} },
+  pivotFieldId: undefined,
+  getPivotAttributes: (id: string) =>
+    id === UNCATEGORIZED_VALUE ? UNCATEGORIZED_ATTRIBUTES : { title: id, color: 'neutral' },
+  itemTile: (() => null) as ComponentType<KanbanCardProps>,
+});
+
+//
+// Root
+//
+
+const KANBAN_BOARD_ROOT = 'KanbanBoard.Root';
+
+type KanbanBoardRootProps = PropsWithChildren<
+  {
+    kanban: Kanban.Kanban;
+    /** Required when providing context; Root derives columnFieldPath, pivotFieldId, getPivotAttributes from kanban + projection. */
+    projection: ProjectionModel;
+    /** Atom of items (e.g. from AtomQuery for DB, or Atom.make([]) for in-memory). */
+    items: Atom.Atom<Obj.Unknown[]>;
+    onCardAdd?: (columnValue: string | undefined) => string | undefined;
+    onCardRemove?: (card: Obj.Unknown) => void;
+  } & Pick<KanbanBoardContextValue, 'change' | 'itemTile'> &
+    ComponentPropsWithoutRef<'div'>
+>;
+
+export const KanbanBoardRoot = ({
+  children,
+  kanban,
+  projection,
+  items,
+  change,
+  itemTile = KanbanCard,
+  onCardAdd,
+  onCardRemove,
+}: KanbanBoardRootProps) => {
+  const registry = useContext(RegistryContext);
+  const { t } = useTranslation(meta.id);
+  const model = useKanbanBoardModel(kanban, projection, items, registry);
+  const columns = model?.getColumns?.() ?? [];
+  const view = kanban?.spec.kind === 'view' ? kanban.spec.view.target : undefined;
+  const pivotFieldId = view?.projection?.pivotFieldId;
+  const columnFieldPath = useMemo(() => {
+    // Items-variant kanbans use the property name itself as the pivot field
+    // (no view/projection translation layer).
+    if (kanban?.spec.kind === 'items') {
+      return kanban.spec.pivotField;
+    }
+    if (pivotFieldId === undefined || !projection) {
+      return undefined;
+    }
+
+    return projection.tryGetFieldProjection(pivotFieldId)?.props.property;
+  }, [kanban?.spec, projection, pivotFieldId]);
+
+  const getPivotAttributes = useCallback<KanbanBoardContextValue['getPivotAttributes']>(
+    (columnValue) => {
+      if (columnValue === UNCATEGORIZED_VALUE) {
+        return UNCATEGORIZED_ATTRIBUTES;
+      }
+
+      const options = projection?.tryGetFieldProjection(pivotFieldId ?? '')?.props.options ?? [];
+      const option = options.find((option) => option.id === columnValue);
+      return option ?? ({ title: columnValue, color: 'neutral' } as const);
+    },
+    [projection, pivotFieldId],
+  );
+
+  if (columns.length === 0) {
+    return (
+      <div role='none' className='flex flex-1 items-center justify-center p-8 text-center text-description'>
+        {t('select-pivot.placeholder')}
+      </div>
+    );
+  }
+
+  return (
+    <KanbanBoardContext
+      kanbanId={Obj.getDXN(kanban).toString()}
+      projection={projection}
+      columnFieldPath={columnFieldPath}
+      pivotFieldId={pivotFieldId}
+      getPivotAttributes={getPivotAttributes}
+      itemTile={itemTile}
+      change={change}
+      onCardAdd={onCardAdd}
+      onCardRemove={onCardRemove}
+    >
+      <Board.Root model={model}>{children}</Board.Root>
+    </KanbanBoardContext>
+  );
+};
+
+KanbanBoardRoot.displayName = KANBAN_BOARD_ROOT;
+
+//
+// KanbanBoardContent
+//
+
+const KANBAN_BOARD_CONTENT = 'KanbanBoard.Content';
+
+type KanbanBoardContentProps = {};
+
+export const KanbanBoardContent = composable<HTMLDivElement, KanbanBoardContentProps>((props, forwardedRef) => {
+  const { model } = useBoard(KANBAN_BOARD_CONTENT);
+  const { kanbanId, projection, pivotFieldId, change } = useKanbanBoard(KANBAN_BOARD_CONTENT);
+
+  const columnEventHandler = useKanbanColumnEventHandler({
+    id: `${kanbanId}-columns`,
+    model,
+    projection: projection ?? undefined,
+    pivotFieldId: pivotFieldId ?? undefined,
+    change,
+  });
+
+  return (
+    <Board.Content
+      {...composableProps(props)}
+      ref={forwardedRef}
+      id={kanbanId}
+      eventHandler={columnEventHandler}
+      Tile={KanbanColumn}
+    />
+  );
+});
+
+KanbanBoardContent.displayName = KANBAN_BOARD_CONTENT;
+
+//
+// KanbanBoard
+//
+
+export const KanbanBoard = {
+  Root: KanbanBoardRoot,
+  Content: KanbanBoardContent,
+  Column: KanbanColumn,
+  Card: KanbanCard,
+};
+
+export { useKanbanBoard };
+
+export type { KanbanBoardRootProps as KanbanBoardProps, KanbanCardProps, KanbanColumnProps };

package/src/components/KanbanBoard/KanbanCard.tsx

@@ -0,0 +1,98 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useCallback, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface, useObjectMenuItems } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { Card, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Menu, createMenuAction } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps, useBoard } from '@dxos/react-ui-mosaic';
+
+import { meta } from '#meta';
+
+import { useKanbanBoard } from './KanbanBoard';
+
+const KANBAN_CARD_TILE_NAME = 'KanbanBoard.Card';
+
+export type KanbanCardProps = Pick<MosaicTileProps<Obj.Unknown>, 'location' | 'data' | 'debug'>;
+
+/**
+ * Mosaic Tile for Kanban card.
+ * Uses Surface for content; requires plugin manager context.
+ */
+export const KanbanCard = forwardRef<HTMLDivElement, KanbanCardProps>(({ data, location, debug }, forwardedRef) => {
+  const { t } = useTranslation(meta.id);
+  const { model } = useBoard(KANBAN_CARD_TILE_NAME);
+  const { projection, columnFieldPath, onCardRemove } = useKanbanBoard(KANBAN_CARD_TILE_NAME);
+  const [dragHandle, setDragHandle] = useState<HTMLButtonElement | null>(null);
+  const dragHandleRef = useCallback((el: HTMLButtonElement | null) => setDragHandle(el), []);
+
+  const objectMenuItems = useObjectMenuItems(data);
+
+  const menuItems = useMemo(
+    () => [
+      ...objectMenuItems,
+      ...(onCardRemove
+        ? [
+            createMenuAction('remove', () => onCardRemove(data), {
+              label: t('remove-card.label'),
+              icon: 'ph--trash--regular',
+            }),
+          ]
+        : []),
+    ],
+    [objectMenuItems, onCardRemove, data, t],
+  );
+
+  return (
+    <Menu.Root>
+      <Mosaic.Tile
+        asChild
+        id={model.getItemId(data)}
+        data={data}
+        location={location}
+        debug={debug}
+        dragHandle={dragHandle}
+      >
+        <Focus.Item asChild>
+          <Card.Root ref={forwardedRef} data-testid='board-item'>
+            <Card.Toolbar>
+              <Card.DragHandle ref={dragHandleRef} testId='mosaicBoard.cardDragHandle' />
+              <Card.Title data-testid='mosaicBoard.cardTitle'>{Obj.getLabel(data)}</Card.Title>
+              {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+              <Menu.Trigger asChild disabled={!menuItems?.length}>
+                <Toolbar.IconButton
+                  iconOnly
+                  variant='ghost'
+                  icon='ph--dots-three-vertical--regular'
+                  label={t('action-menu.label')}
+                />
+              </Menu.Trigger>
+              <Menu.Content items={menuItems} />
+            </Card.Toolbar>
+            <Card.Content>
+              {projection && (
+                <Surface.Surface
+                  type={AppSurface.Card}
+                  limit={1}
+                  data={{
+                    subject: data,
+                    projection,
+                    // Hide the pivot field: its value is already conveyed by
+                    // which column the card sits in.
+                    ignorePaths: columnFieldPath ? [columnFieldPath] : undefined,
+                  }}
+                />
+              )}
+            </Card.Content>
+          </Card.Root>
+        </Focus.Item>
+      </Mosaic.Tile>
+    </Menu.Root>
+  );
+});
+
+KanbanCard.displayName = KANBAN_CARD_TILE_NAME;

package/src/components/KanbanBoard/KanbanColumn.tsx

@@ -0,0 +1,71 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { FC, forwardRef, RefObject, useRef } from 'react';
+
+import type { Obj } from '@dxos/echo';
+import { Board, type MosaicTileProps, useBoard } from '@dxos/react-ui-mosaic';
+
+import { useKanbanItemEventHandler } from '#hooks';
+import { type ColumnStructure, UNCATEGORIZED_VALUE } from '#types';
+
+import { useKanbanBoard } from './KanbanBoard';
+
+const KANBAN_COLUMN_NAME = 'KanbanBoard.Column';
+
+export type KanbanColumnProps = Pick<MosaicTileProps<ColumnStructure>, 'location' | 'data' | 'debug'>;
+
+/**
+ * Mosaic Tile for Kanban column.
+ */
+export const KanbanColumn = forwardRef<HTMLDivElement, KanbanColumnProps>(
+  ({ data: column, location, debug }, forwardedRef) => {
+    const { model } = useBoard<ColumnStructure, Obj.Unknown>(KANBAN_COLUMN_NAME);
+    const { columnFieldPath, change, onCardAdd, getPivotAttributes, itemTile } = useKanbanBoard(KANBAN_COLUMN_NAME);
+
+    const { title } = getPivotAttributes(column.columnValue);
+    const uncategorized = column.columnValue === UNCATEGORIZED_VALUE;
+    const dragHandleRef = useRef<HTMLButtonElement | null>(null);
+
+    const eventHandler = useKanbanItemEventHandler({
+      column,
+      columnFieldPath,
+      model,
+      change,
+    });
+
+    return (
+      <Board.Column.Root
+        data={column}
+        location={location}
+        classNames='grid grid-rows-[var(--dx-rail-action)_1fr_var(--dx-rail-action)]'
+        debug={debug}
+        dragHandleRef={dragHandleRef}
+        ref={forwardedRef}
+      >
+        {uncategorized ? (
+          <div className='border-b border-separator p-2' data-testid='board-column-header'>
+            <span className='font-medium'>{title}</span>
+          </div>
+        ) : (
+          <Board.Column.Header label={title} dragHandleRef={dragHandleRef as RefObject<HTMLButtonElement>} />
+        )}
+        <Board.Column.Body
+          data={column}
+          eventHandler={eventHandler}
+          Tile={itemTile as FC<MosaicTileProps<Obj.Unknown>>}
+        />
+        <Board.Column.Footer
+          onAdd={
+            onCardAdd
+              ? () => onCardAdd(column.columnValue === UNCATEGORIZED_VALUE ? undefined : column.columnValue)
+              : undefined
+          }
+        />
+      </Board.Column.Root>
+    );
+  },
+);
+
+KanbanColumn.displayName = KANBAN_COLUMN_NAME;

package/src/components/KanbanBoard/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './KanbanBoard';

package/src/components/index.ts

@@ -2,5 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './KanbanContainer';
-export * from './KanbanViewEditor';
+export * from './KanbanBoard';