@dxos/plugin-kanban 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,86 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
+import React, { useMemo } from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { Database, JsonSchema, Obj } from '@dxos/echo';
+import { type Collection } from '@dxos/echo';
+import { findAnnotation } from '@dxos/effect';
+import { type FormFieldComponentProps, SelectField, useFormValues } from '@dxos/react-ui-form';
+
+import { KanbanContainer, KanbanViewEditor } from '../../containers';
+import { meta } from '../../meta';
+import { Kanban, PivotColumnAnnotationId } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: meta.id,
+        role: ['article', 'section'],
+        filter: (data): data is { subject: Kanban.Kanban } => Obj.instanceOf(Kanban.Kanban, data.subject),
+        component: ({ data, role }) => <KanbanContainer role={role} subject={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}/object-settings`,
+        role: 'object-settings',
+        position: 'hoist',
+        filter: (data): data is { subject: Kanban.Kanban } => Obj.instanceOf(Kanban.Kanban, data.subject),
+        component: ({ data }) => <KanbanViewEditor subject={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}/create-initial-schema-form-[pivot-column]`,
+        role: 'form-input',
+        filter: (
+          data,
+        ): data is {
+          prop: string;
+          schema: Schema.Schema<any>;
+          target: Database.Database | Collection.Collection | undefined;
+        } => {
+          const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, PivotColumnAnnotationId);
+          return !!annotation;
+        },
+        component: ({ data: { target }, ...inputProps }) => {
+          const props = inputProps as any as FormFieldComponentProps;
+          const db = Database.isDatabase(target) ? target : target && Obj.getDatabase(target);
+          if (!db) {
+            return null;
+          }
+
+          const { typename } = useFormValues('KanbanForm');
+          const [selectedSchema] = useMemo(
+            () => db.schemaRegistry.query({ location: ['database', 'runtime'], typename }).runSync(),
+            [db, typename],
+          );
+          const singleSelectColumns = useMemo(() => {
+            const properties = JsonSchema.toJsonSchema(selectedSchema).properties;
+            if (!properties) {
+              return [];
+            }
+
+            const columns = Object.entries(properties).reduce<string[]>((acc, [key, value]) => {
+              if (typeof value === 'object' && value?.format === 'single-select') {
+                acc.push(key);
+              }
+              return acc;
+            }, []);
+
+            return columns;
+          }, [selectedSchema]);
+
+          if (!typename) {
+            return null;
+          }
+
+          return <SelectField {...props} options={singleSelectColumns.map((column) => ({ value: column }))} />;
+        },
+      }),
+    ]),
+  ),
+);

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

@@ -0,0 +1,142 @@
+//
+// 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 { faker } from '@dxos/random';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { withMosaic } from '@dxos/react-ui-mosaic/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';
+
+faker.seed(1);
+
+const createOrg = () => ({
+  name: faker.commerce.productName(),
+  description: faker.lorem.sentence(),
+  image: faker.image.url(),
+  website: faker.internet.url(),
+  status: faker.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: faker.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 <></>;
+  }
+
+  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,184 @@
+//
+// 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 { 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<
+  Pick<KanbanBoardContextValue, 'change' | 'itemTile'> & {
+    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;
+  } & ComponentPropsWithoutRef<'div'>
+>;
+
+export const KanbanBoardRoot = ({
+  children,
+  change,
+  itemTile = KanbanCard,
+  kanban,
+  projection,
+  items,
+  onCardAdd,
+  onCardRemove,
+  ...props
+}: KanbanBoardRootProps) => {
+  const registry = useContext(RegistryContext);
+  const { t } = useTranslation(meta.id);
+  const model = useKanbanBoardModel(kanban, projection, items, registry);
+  const columns = model?.getColumns?.() ?? [];
+  const view = kanban?.view?.target;
+  const pivotFieldId = view?.projection?.pivotFieldId;
+  const columnFieldPath = useMemo(() => {
+    if (pivotFieldId === undefined || !projection) {
+      return undefined;
+    }
+
+    return projection.tryGetFieldProjection(pivotFieldId)?.props.property;
+  }, [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 {...props} 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}>
+        <div {...props}>{children}</div>
+      </Board.Root>
+    </KanbanBoardContext>
+  );
+};
+
+KanbanBoardRoot.displayName = KANBAN_BOARD_ROOT;
+
+//
+// KanbanBoardContent
+//
+
+const KANBAN_BOARD_CONTENT = 'KanbanBoard.Content';
+
+export const KanbanBoardContent = () => {
+  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 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,87 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useCallback, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { useObjectMenuItems, useObjectNavigate } 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, 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 handleNavigate = useObjectNavigate(data);
+
+  const menuItems = useMemo(
+    () => [
+      ...objectMenuItems,
+      ...(onCardRemove
+        ? [
+            createMenuAction('remove', () => onCardRemove(data), {
+              label: t('remove card label'),
+              icon: 'ph--trash--regular',
+            }),
+          ]
+        : []),
+    ],
+    [objectMenuItems, onCardRemove, data, t],
+  );
+
+  return (
+    <Mosaic.Tile
+      asChild
+      id={model.getItemId(data)}
+      data={data}
+      location={location}
+      debug={debug}
+      dragHandle={dragHandle}
+    >
+      <Focus.Group asChild>
+        <Menu.Root>
+          <Card.Root ref={forwardedRef} data-testid='board-item'>
+            <Card.Toolbar>
+              <Card.DragHandle ref={dragHandleRef} />
+              <Card.Title onClick={handleNavigate}>{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 role='card--content' limit={1} data={{ subject: data, projection }} />}
+            </Card.Content>
+          </Card.Root>
+        </Menu.Root>
+      </Focus.Group>
+    </Mosaic.Tile>
+  );
+});
+
+KanbanCard.displayName = KANBAN_CARD_TILE_NAME;

package/src/components/KanbanBoard/KanbanColumn.tsx

@@ -0,0 +1,69 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, 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 React.RefObject<HTMLButtonElement>} />
+        )}
+        <Board.Column.Body
+          data={column}
+          eventHandler={eventHandler}
+          Tile={itemTile as React.FC<MosaicTileProps<Obj.Unknown>>}
+        />
+        {onCardAdd && (
+          <Board.Column.Footer
+            onAdd={() => onCardAdd(column.columnValue === UNCATEGORIZED_VALUE ? undefined : column.columnValue)}
+          />
+        )}
+      </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';