@dxos/plugin-kanban 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

package/src/testing/KanbanCardTileSimple.tsx

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useCallback, useMemo, useState } from 'react';
+
+import { Obj } from '@dxos/echo';
+import { Card, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Menu, createMenuAction } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, useBoard } from '@dxos/react-ui-mosaic';
+
+import { type KanbanCardProps, useKanbanBoard } from '#components';
+import { meta } from '#meta';
+
+const KANBAN_CARD_TILE_SIMPLE_NAME = 'KanbanCardTileSimple';
+
+/**
+ * Card tile without Surface; for stories and tests when plugin manager is not available.
+ */
+export const KanbanCardTileSimple = forwardRef<HTMLDivElement, KanbanCardProps>(
+  ({ data, location, debug }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+    const { model } = useBoard(KANBAN_CARD_TILE_SIMPLE_NAME);
+    const { onCardRemove } = useKanbanBoard(KANBAN_CARD_TILE_SIMPLE_NAME);
+    const [dragHandle, setDragHandle] = useState<HTMLButtonElement | null>(null);
+    const dragHandleRef = useCallback((el: HTMLButtonElement | null) => setDragHandle(el), []);
+
+    const menuItems = useMemo(
+      () =>
+        onCardRemove
+          ? [
+              createMenuAction('remove', () => onCardRemove(data), {
+                label: t('remove-card.label'),
+                icon: 'ph--trash--regular',
+              }),
+            ]
+          : [],
+      [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} />
+                <Card.Title>{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>
+                <Card.Section>
+                  <pre className='p-2 text-xs text-description whitespace-pre-wrap'>
+                    {JSON.stringify(data, null, 2)}
+                  </pre>
+                </Card.Section>
+              </Card.Content>
+            </Card.Root>
+          </Focus.Item>
+        </Mosaic.Tile>
+      </Menu.Root>
+    );
+  },
+);
+
+KanbanCardTileSimple.displayName = KANBAN_CARD_TILE_SIMPLE_NAME;

package/src/testing/index.ts

@@ -1,6 +1,5 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-export * from './kanban-manager';
-export * from './initialize-kanban';
+export { KanbanCardTileSimple } from './KanbanCardTileSimple';

package/src/translations.ts

@@ -2,34 +2,42 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
-import { KanbanType } from '@dxos/react-ui-kanban';
 
-import { meta } from './meta';
+import { meta } from '#meta';
+import { Kanban } from '#types';
 
 export const translations = [
   {
     'en-US': {
-      [KanbanType.typename]: {
-        'typename label': 'Kanban',
-        'typename label_zero': 'Kanbans',
-        'typename label_one': 'Kanban',
-        'typename label_other': 'Kanbans',
-        'object name placeholder': 'New kanban',
+      [Type.getTypename(Kanban.Kanban)]: {
+        'typename.label': 'Kanban',
+        'typename.label_zero': 'Kanbans',
+        'typename.label_one': 'Kanban',
+        'typename.label_other': 'Kanbans',
+        'object-name.placeholder': 'New kanban',
+        'add-object.label': 'Add kanban',
+        'rename-object.label': 'Rename kanban',
+        'delete-object.label': 'Delete kanban',
+        'object-deleted.label': 'Kanban deleted',
       },
       [meta.id]: {
-        'plugin name': 'Kanban',
-        'kanban title label': 'Title',
-        'column title label': 'Column title',
-        'column title placeholder': 'New column',
-        'item title label': 'Item title',
-        'item title placeholder': 'New item',
-        'add column label': 'Add column',
-        'add item label': 'Add card',
-        'delete column label': 'Delete column',
-        'delete item label': 'Delete card',
-        'card field deleted label': 'Card field deleted',
-        'card deleted label': 'Card deleted',
+        'action-menu.label': 'Actions',
+        'plugin.name': 'Kanban',
+        'kanban-title.label': 'Title',
+        'column-title.label': 'Column title',
+        'column-title.placeholder': 'New column',
+        'add-column.label': 'Add column',
+        'add-card.label': 'Add card',
+        'new-column-name.label': 'New column name',
+        'remove-card.label': 'Remove card',
+        'remove-empty-column.label': 'Remove empty column',
+        'column-drag-handle.label': 'Drag to rearrange',
+        'delete-column.label': 'Delete column',
+        'card-field-deleted.label': 'Card field deleted',
+        'card-deleted.label': 'Card deleted',
+        'select-pivot.placeholder': 'Select a pivot column in board settings to display columns.',
       },
     },
   },

package/src/types/Kanban.ts

@@ -0,0 +1,151 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { View } from '@dxos/echo';
+import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+import { ViewAnnotation } from '@dxos/schema';
+
+/**
+ * Per-column entry: ordered card ids plus an optional `hidden` flag that
+ * removes the column from the rendered board (and from the model's column
+ * list). Today only the uncategorized column is exposed in settings, but
+ * the data structure supports per-column hiding generally.
+ */
+const ArrangementColumnEntry = Schema.Struct({
+  ids: Schema.Array(Obj.ID),
+  hidden: Schema.Boolean.pipe(Schema.optional),
+});
+
+/** Keyed by columnValue. */
+const ArrangementColumns = Schema.Record({
+  key: Schema.String,
+  value: ArrangementColumnEntry,
+}).pipe(FormInputAnnotation.set(false));
+
+/** Column order and per-column card ids. */
+export const Arrangement = Schema.Struct({
+  order: Schema.Array(Schema.String).pipe(FormInputAnnotation.set(false)),
+  columns: ArrangementColumns,
+}).pipe(FormInputAnnotation.set(false));
+
+export type Arrangement = Schema.Schema.Type<typeof Arrangement>;
+
+/**
+ * v1: pre-existing Kanban shape. Retained as the source for the v1→v2 migration.
+ */
+export const KanbanV1 = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
+  arrangement: Arrangement,
+}).pipe(
+  Type.object({
+    typename: 'org.dxos.type.kanban',
+    version: '0.1.0',
+  }),
+);
+
+//
+// v2 — `spec` is a discriminated union of how items are sourced.
+//
+// Mirrors the canonical DXOS pattern (see `Trigger.Spec` in
+// `@dxos/functions/src/types/Trigger.ts` and `Sequence.Source` in
+// `@dxos/plugin-zen`): the `Type.object` schema is a flat `Schema.Struct`,
+// and the discriminated union lives one level down as a single field whose
+// variants are tagged with a `kind` literal.
+//
+
+/** View-variant: items come from running the View's query (the original behaviour). */
+export const KanbanViewSpec = Schema.Struct({
+  kind: Schema.Literal('view').pipe(FormInputAnnotation.set(false)),
+  view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
+});
+export type KanbanViewSpec = Schema.Schema.Type<typeof KanbanViewSpec>;
+
+/** Items-variant: kanban owns its items as an explicit ref array (used by externally-synced kanbans). */
+export const KanbanItemsSpec = Schema.Struct({
+  kind: Schema.Literal('items').pipe(FormInputAnnotation.set(false)),
+  /** Property path on each item that drives column membership (e.g. `'listName'`). */
+  pivotField: Schema.String,
+  /** Items owned directly by the kanban. */
+  items: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(FormInputAnnotation.set(false)),
+});
+export type KanbanItemsSpec = Schema.Schema.Type<typeof KanbanItemsSpec>;
+
+/** Discriminated union of source specs. Distinguished by `kind`. */
+export const KanbanSpec = Schema.Union(KanbanViewSpec, KanbanItemsSpec);
+export type KanbanSpec = Schema.Schema.Type<typeof KanbanSpec>;
+
+export const Kanban = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  arrangement: Arrangement,
+  /** How this kanban sources its items. Discriminated by `spec.kind`. */
+  spec: KanbanSpec,
+}).pipe(
+  Type.object({
+    typename: 'org.dxos.type.kanban',
+    version: '0.2.0',
+  }),
+  LabelAnnotation.set(['name']),
+  ViewAnnotation.set(['spec', 'view']),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--kanban--regular',
+    hue: 'green',
+  }),
+);
+
+/** Instance type; narrow on `kanban.spec.kind` (or use the guards below). */
+export interface Kanban extends Schema.Schema.Type<typeof Kanban> {}
+
+/** Narrowed view-variant kanban. */
+export type KanbanView = Kanban & { spec: KanbanViewSpec };
+
+/** Narrowed items-variant kanban. */
+export type KanbanItems = Kanban & { spec: KanbanItemsSpec };
+
+export const isKanbanView = (kanban: Kanban): kanban is KanbanView => kanban.spec.kind === 'view';
+export const isKanbanItems = (kanban: Kanban): kanban is KanbanItems => kanban.spec.kind === 'items';
+
+type MakeViewProps = {
+  name?: string;
+  view: View.View;
+  arrangement?: Arrangement;
+};
+
+/**
+ * Make a view-variant kanban (items sourced via the View's query).
+ */
+export const make = (props: MakeViewProps): Kanban => {
+  const { name, view, arrangement } = props;
+  const order = arrangement?.order ?? [];
+  const columns = arrangement?.columns ?? {};
+  return Obj.make(Kanban, {
+    name,
+    arrangement: { order, columns },
+    spec: { kind: 'view' as const, view: Ref.make(view) },
+  });
+};
+
+type MakeItemsProps = {
+  name?: string;
+  arrangement?: Arrangement;
+  pivotField: string;
+  items?: ReadonlyArray<Ref.Ref<Obj.Unknown>>;
+};
+
+/**
+ * Make an items-variant kanban (items list owned by the kanban itself, e.g. populated by a sync integration).
+ */
+export const makeItems = (props: MakeItemsProps): Kanban => {
+  const { name, arrangement, pivotField, items = [] } = props;
+  const order = arrangement?.order ?? [];
+  const columns = arrangement?.columns ?? {};
+  return Obj.make(Kanban, {
+    name,
+    arrangement: { order, columns },
+    spec: { kind: 'items' as const, pivotField, items },
+  });
+};

package/src/types/constants.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const UNCATEGORIZED_VALUE = '__uncategorized__' as const;
+export const UNCATEGORIZED_ATTRIBUTES = {
+  title: 'Uncategorized',
+  color: 'neutral',
+} as const;

package/src/types/index.ts

@@ -2,5 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './constants';
+export * as Kanban from './Kanban';
 export * from './schema';
-export * from './types';
+export type * from './types';

package/src/types/migrations.test.ts

@@ -0,0 +1,83 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { afterEach, beforeEach, describe, test } from 'vitest';
+
+import { defineObjectMigration } from '@dxos/client/echo';
+import { Filter, JsonSchema, Obj, Query, Ref, Type, View } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { ViewModel } from '@dxos/schema';
+
+import { Kanban } from './Kanban';
+import { KanbanV1 } from './Kanban';
+
+const TestCardSchema = Schema.Struct({ id: Schema.String }).pipe(
+  Type.object({ typename: 'com.example/TestCard', version: '0.1.0' }),
+);
+
+/**
+ * v0.1.0 → v0.2.0 migration: nests `view` under `spec: { kind: 'view', view }`.
+ *
+ * Mirrors the migration registered in `capabilities/migrations.ts`. Running it
+ * here against a real ECHO database verifies that the transform produces a
+ * v0.2.0-shaped object that's queryable as `Kanban.Kanban`.
+ */
+describe('Kanban migration v1 → v2', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  const migration = defineObjectMigration({
+    from: KanbanV1,
+    to: Kanban,
+    transform: async (from) => ({
+      name: from.name,
+      arrangement: from.arrangement,
+      spec: { kind: 'view' as const, view: from.view },
+    }),
+    onMigration: async () => {},
+  });
+
+  test('migrates a v1 Kanban into the v2 view-variant shape', async ({ expect }) => {
+    const { db, graph } = await builder.createDatabase();
+    await graph.schemaRegistry.register([KanbanV1, Kanban, View.View]);
+
+    // Build a real View object so the v1 Kanban has a valid ref to migrate.
+    const view = ViewModel.make({
+      query: Query.select(Filter.type(TestCardSchema)),
+      jsonSchema: JsonSchema.toJsonSchema(TestCardSchema),
+    });
+    db.add(view);
+
+    db.add(
+      Obj.make(KanbanV1, {
+        name: 'My Board',
+        view: Ref.make(view),
+        arrangement: { order: ['todo'], columns: { todo: { ids: [] } } },
+      }),
+    );
+    await db.flush();
+
+    await db.runMigrations([migration]);
+
+    const results = await db.query(Filter.type(Kanban)).run();
+    expect(results).toHaveLength(1);
+
+    const migrated = results[0];
+    expect(migrated.name).toBe('My Board');
+    expect(migrated.arrangement.order).toEqual(['todo']);
+    expect(migrated.spec.kind).toBe('view');
+    if (migrated.spec.kind === 'view') {
+      expect(migrated.spec.view.dxn.toString()).toBe(Ref.make(view).dxn.toString());
+    }
+    expect(Type.getVersion(Obj.getSchema(migrated)!)).toBe('0.2.0');
+  });
+});

package/src/types/schema.ts

@@ -2,13 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { SpaceSchema } from '@dxos/react-client/echo';
-import { KanbanType } from '@dxos/react-ui-kanban';
-import { FieldSchema, TypenameAnnotationId } from '@dxos/schema';
-
-import { KANBAN_PLUGIN } from '../meta';
+import { TypeInputOptionsAnnotation } from '@dxos/plugin-space/types';
 
 /**
  * Kanban data model.
@@ -22,13 +18,40 @@ import { KANBAN_PLUGIN } from '../meta';
 // TODO(wittjosiah): Factor out?
 export const PivotColumnAnnotationId = Symbol.for('@dxos/plugin-kanban/annotation/PivotColumn');
 
+/**
+ * Settings common to every Kanban (view or items). Rendered as form fields
+ * by `KanbanSettings`.
+ */
+export const KanbanSettingsSchema = Schema.Struct({
+  hideUncategorized: Schema.Boolean.annotations({
+    title: 'Hide uncategorized column',
+    description: 'When enabled, items without a pivot value won’t be shown as a column.',
+  }).pipe(Schema.optional),
+});
+
+/**
+ * Settings for view-variant Kanbans only. Spreads {@link KanbanSettingsSchema}'s
+ * fields and adds a column-field picker that binds the View’s pivot field.
+ * Items-variant kanbans use a hardcoded `spec.pivotField` and don’t expose
+ * this control.
+ */
+export const KanbanViewSettingsSchema = Schema.Struct({
+  columnFieldId: Schema.String.annotations({
+    title: 'Column field',
+  }),
+  ...KanbanSettingsSchema.fields,
+});
+
 export const CreateKanbanSchema = Schema.Struct({
   name: Schema.optional(Schema.String),
-  typename: Schema.optional(
-    Schema.String.annotations({
-      [TypenameAnnotationId]: ['limited-static', 'dynamic'],
-      title: 'Select card schema (leave empty to start fresh)',
+  // TODO(wittjosiah): This should be a query input instead.
+  typename: Schema.String.pipe(
+    Schema.annotations({ title: 'Select card type' }),
+    TypeInputOptionsAnnotation.set({
+      location: ['database', 'runtime'],
+      kind: ['user'],
     }),
+    Schema.optional,
   ),
   initialPivotColumn: Schema.optional(
     Schema.String.annotations({
@@ -37,39 +60,3 @@ export const CreateKanbanSchema = Schema.Struct({
     }),
   ),
 });
-
-export namespace KanbanAction {
-  const KANBAN_ACTION = `${KANBAN_PLUGIN}/action`;
-
-  export class Create extends Schema.TaggedClass<Create>()(`${KANBAN_ACTION}/create`, {
-    input: Schema.extend(Schema.Struct({ space: SpaceSchema }), CreateKanbanSchema),
-    output: Schema.Struct({
-      object: KanbanType,
-    }),
-  }) {}
-
-  export class DeleteCardField extends Schema.TaggedClass<DeleteCardField>()(`${KANBAN_ACTION}/delete-card-field`, {
-    input: Schema.Struct({
-      kanban: KanbanType,
-      fieldId: Schema.String,
-      // TODO(wittjosiah): Separate fields for undo data?
-      deletionData: Schema.optional(
-        Schema.Struct({
-          field: FieldSchema,
-          // TODO(wittjosiah): This creates a type error.
-          // props: PropertySchema,
-          props: Schema.Any,
-          index: Schema.Number,
-        }),
-      ),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class DeleteCard extends Schema.TaggedClass<DeleteCard>()(`${KANBAN_ACTION}/delete-card`, {
-    input: Schema.Struct({
-      card: Schema.Any, // The card object to delete
-    }),
-    output: Schema.Void,
-  }) {}
-}

package/src/types/types.ts

@@ -2,21 +2,41 @@
 // Copyright 2025 DXOS.org
 //
 
-import { KanbanType } from '@dxos/react-ui-kanban';
+import { type Obj } from '@dxos/echo';
+
+import { type Kanban } from './Kanban';
 
 export type Location = {
   idx?: number;
 };
 
-/**
- * @deprecated
- */
-// TODO(burdon): Remove?
-export interface KanbanModel {
-  root: KanbanType;
-}
+/** Snapshot shape used when reading kanban arrangement from atoms. */
+export type KanbanArrangementSnapshot = Kanban | Obj.Snapshot<Kanban>;
+
+/** Minimal item shape for arrangement; Obj.Unknown satisfies this. */
+export type BaseKanbanItem = { id: string };
+
+/** Column structure without cards; used for board model column type and derived atoms. */
+export type ColumnStructure = {
+  columnValue: string;
+  ids: string[];
+};
+
+export type KanbanColumn<T extends BaseKanbanItem = BaseKanbanItem> = {
+  columnValue: string;
+  cards: T[];
+};
+
+export type ArrangedCards<T extends BaseKanbanItem = BaseKanbanItem> = KanbanColumn<T>[];
 
 /**
- * @deprecated Use Type.isInstance()
+ * Callback type for wrapping mutations in Obj.update().
+ * Contains separate callbacks for kanban object and item mutations.
  */
-export const isKanban = (object: unknown): object is KanbanType => object != null && object instanceof KanbanType;
+export type KanbanChangeCallback<T extends BaseKanbanItem> = {
+  /** Callback to wrap kanban object mutations. */
+  kanban: (mutate: (mutableKanban: Obj.Mutable<Kanban>) => void) => void;
+
+  /** Sets a field on an item, wrapping in Obj.update() if needed. */
+  setItemField: (item: T, field: string, value: unknown) => void;
+};