@dxos/plugin-kanban 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/types/types.ts

@@ -2,6 +2,41 @@
 // Copyright 2025 DXOS.org
 //
 
+import { type Obj } from '@dxos/echo';
+
+import { type Kanban } from './Kanban';
+
 export type Location = {
   idx?: number;
 };
+
+/** 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>[];
+
+/**
+ * Callback type for wrapping mutations in Obj.change().
+ * Contains separate callbacks for kanban object and item mutations.
+ */
+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.change() if needed. */
+  setItemField: (item: T, field: string, value: unknown) => void;
+};

package/src/util/arrangement.test.ts

@@ -0,0 +1,208 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { beforeEach, describe, test } from 'vitest';
+
+import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { type View } from '@dxos/echo';
+import { ObjectId } from '@dxos/keys';
+import { ViewModel } from '@dxos/schema';
+
+import { Kanban, UNCATEGORIZED_VALUE } from '#types';
+
+import {
+  computeColumnStructure,
+  computeItemArrangement,
+  getOrderByColumnFromArrangement,
+  getOrderFromArrangement,
+} from './arrangement';
+
+const selectOptions = [
+  { id: UNCATEGORIZED_VALUE, title: 'Uncategorized', color: 'neutral' },
+  { id: 'a', title: 'A', color: 'blue' },
+  { id: 'b', title: 'B', color: 'green' },
+];
+
+const MinimalSchema = Schema.Struct({ id: Schema.String }).pipe(
+  Type.object({ typename: 'test/Minimal', version: '0.1.0' }),
+);
+
+describe('arrangement utils', () => {
+  let view: View.View;
+
+  beforeEach(() => {
+    view = ViewModel.make({
+      query: Query.select(Filter.type(MinimalSchema)),
+      jsonSchema: JsonSchema.toJsonSchema(MinimalSchema),
+    });
+  });
+
+  describe('getOrderFromArrangement', () => {
+    test('returns copy of order when present', ({ expect }) => {
+      const arrangement = { order: ['a', 'b'], columns: {} };
+      expect(getOrderFromArrangement(arrangement)).toEqual(['a', 'b']);
+    });
+
+    test('returns copy of order from kanban arrangement', ({ expect }) => {
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: ['b', 'a'], columns: {} },
+      });
+      const order = getOrderFromArrangement(kanban.arrangement);
+      expect(order).toEqual(['b', 'a']);
+      order.push('x');
+      expect(getOrderFromArrangement(kanban.arrangement)).toEqual(['b', 'a']);
+    });
+
+    test('returns empty when arrangement or order missing or empty', ({ expect }) => {
+      expect(getOrderFromArrangement(undefined)).toEqual([]);
+      expect(getOrderFromArrangement({ order: [], columns: {} })).toEqual([]);
+      const kanbanEmptyOrder = Kanban.make({
+        view,
+        arrangement: { order: [], columns: {} },
+      });
+      expect(getOrderFromArrangement(kanbanEmptyOrder.arrangement)).toEqual([]);
+    });
+  });
+
+  describe('getOrderByColumnFromArrangement', () => {
+    test('returns per-column data with mutable id arrays', ({ expect }) => {
+      const arrangement = {
+        order: [],
+        columns: { a: { ids: ['i1'] } },
+      };
+      const byColumn = getOrderByColumnFromArrangement(arrangement);
+      expect(byColumn.a.ids).toEqual(['i1']);
+      byColumn.a.ids.push('i2');
+      expect(getOrderByColumnFromArrangement(arrangement).a.ids).toEqual(['i1']);
+    });
+
+    test('returns per-column ids and preserves hidden from kanban arrangement', ({ expect }) => {
+      const id1 = ObjectId.random();
+      const id2 = ObjectId.random();
+      const id3 = ObjectId.random();
+      const kanban = Kanban.make({
+        view,
+        arrangement: {
+          order: [],
+          columns: {
+            a: { ids: [id1, id2], hidden: true },
+            b: { ids: [id3] },
+          },
+        },
+      });
+      const byColumn = getOrderByColumnFromArrangement(kanban.arrangement);
+      expect(byColumn.a).toEqual({ ids: [id1, id2], hidden: true });
+      expect(byColumn.b).toEqual({ ids: [id3] });
+      expect(byColumn.b.hidden).toBeUndefined();
+    });
+
+    test('returns mutable copies', ({ expect }) => {
+      const idX = ObjectId.random();
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: [], columns: { a: { ids: [idX] } } },
+      });
+      const byColumn = getOrderByColumnFromArrangement(kanban.arrangement);
+      byColumn.a.ids.push(ObjectId.random());
+      expect(getOrderByColumnFromArrangement(kanban.arrangement).a.ids).toEqual([idX]);
+    });
+
+    test('returns empty object when arrangement or columns missing', ({ expect }) => {
+      expect(getOrderByColumnFromArrangement(undefined)).toEqual({});
+      expect(getOrderByColumnFromArrangement({ order: [], columns: {} })).toEqual({});
+      const kanbanEmpty = Kanban.make({
+        view,
+        arrangement: { order: [], columns: {} },
+      });
+      expect(getOrderByColumnFromArrangement(kanbanEmpty.arrangement)).toEqual({});
+    });
+  });
+
+  describe('computeColumnStructure', () => {
+    test('uncategorized first, then effectiveOrder, then missing selectOptions', ({ expect }) => {
+      const effectiveOrder = ['b'];
+      const effectiveByColumn = { [UNCATEGORIZED_VALUE]: { ids: ['x'] }, b: { ids: ['y'] } };
+      const result = computeColumnStructure(effectiveOrder, effectiveByColumn, selectOptions);
+      expect(result.map((col) => col.columnValue)).toEqual([UNCATEGORIZED_VALUE, 'b', 'a']);
+      expect(result[0].ids).toEqual(['x']);
+      expect(result[1].ids).toEqual(['y']);
+      expect(result[2].ids).toEqual([]);
+    });
+
+    test('does not duplicate uncategorized when already in effectiveOrder', ({ expect }) => {
+      const effectiveOrder = [UNCATEGORIZED_VALUE, 'a'];
+      const effectiveByColumn = {};
+      const result = computeColumnStructure(effectiveOrder, effectiveByColumn, selectOptions);
+      expect(result.map((col) => col.columnValue)).toEqual([UNCATEGORIZED_VALUE, 'a', 'b']);
+    });
+  });
+
+  describe('computeItemArrangement', () => {
+    test('distributes items by pivotPath and preserves saved order within column', ({ expect }) => {
+      const idUc1 = ObjectId.random();
+      const idA1 = ObjectId.random();
+      const idA2 = ObjectId.random();
+      const idA3 = ObjectId.random();
+      const kanban = Kanban.make({
+        view,
+        arrangement: {
+          order: ['a', 'b'],
+          columns: {
+            [UNCATEGORIZED_VALUE]: { ids: [idUc1] },
+            a: { ids: [idA2, idA1] },
+            b: { ids: [] },
+          },
+        },
+      });
+      const items = [{ id: idA1, status: 'a' }, { id: idA2, status: 'a' }, { id: idA3, status: 'a' }, { id: idUc1 }];
+      const result = computeItemArrangement({
+        object: kanban,
+        items,
+        pivotPath: 'status',
+        selectOptions,
+      });
+      const colUncat = result.find((c) => c.columnValue === UNCATEGORIZED_VALUE);
+      const colA = result.find((c) => c.columnValue === 'a');
+      const colB = result.find((c) => c.columnValue === 'b');
+      expect(colUncat?.cards.map((c) => c.id)).toEqual([idUc1]);
+      expect(colA?.cards.map((c) => c.id)).toEqual([idA2, idA1, idA3]);
+      expect(colB?.cards.map((c) => c.id)).toEqual([]);
+    });
+
+    test('when pivotPath undefined all items go to uncategorized', ({ expect }) => {
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: ['a', 'b'], columns: { a: { ids: [] }, b: { ids: [] } } },
+      });
+      const items = [
+        { id: '1', status: 'a' },
+        { id: '2', status: 'b' },
+      ];
+      const result = computeItemArrangement({
+        object: kanban,
+        items,
+        selectOptions,
+      });
+      const colUncat = result.find((c) => c.columnValue === UNCATEGORIZED_VALUE);
+      const colA = result.find((c) => c.columnValue === 'a');
+      expect(colUncat?.cards.length).toBe(2);
+      expect(colA?.cards.length).toBe(0);
+    });
+
+    test('column order is uncategorized then selectOptions', ({ expect }) => {
+      const kanban = Kanban.make({
+        view,
+        arrangement: { order: ['a', 'b'], columns: {} },
+      });
+      const result = computeItemArrangement({
+        object: kanban,
+        items: [],
+        selectOptions,
+      });
+      expect(result.map((c) => c.columnValue)).toEqual([UNCATEGORIZED_VALUE, 'a', 'b']);
+    });
+  });
+});

package/src/util/arrangement.ts

@@ -0,0 +1,167 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type SelectOption } from '@dxos/echo/internal';
+
+import {
+  type ArrangedCards,
+  type BaseKanbanItem,
+  type ColumnStructure,
+  type Kanban,
+  UNCATEGORIZED_VALUE,
+} from '#types';
+
+/**
+ * Column order from a raw arrangement object (e.g. when working with arrangement only).
+ *
+ * @param arrangement - Optional arrangement; reads order.
+ * @returns Mutable copy of order array, or empty if arrangement/order missing or empty.
+ */
+export const getOrderFromArrangement = (arrangement?: Kanban.Arrangement): string[] => {
+  const order = arrangement?.order;
+  if (order != null && order.length > 0) {
+    return [...order];
+  }
+
+  return [];
+};
+
+/**
+ * Per-column card id order and optional hidden flag from a raw arrangement object.
+ *
+ * Returns mutable copies so schema readonly does not leak to callers.
+ *
+ * @param arrangement - Optional arrangement; reads columns.
+ * @returns Map of column value → { ids, hidden? }; empty object if not set.
+ */
+export const getOrderByColumnFromArrangement = (
+  arrangement?: Kanban.Arrangement,
+): Record<string, { ids: string[]; hidden?: boolean }> => {
+  const columns = arrangement?.columns;
+  if (columns != null && Object.keys(columns).length > 0) {
+    return Object.fromEntries(
+      Object.entries(columns).map(([key, entry]) => [
+        key,
+        { ids: [...(entry.ids ?? [])], ...(entry.hidden !== undefined && { hidden: entry.hidden }) },
+      ]),
+    );
+  }
+
+  return {};
+};
+
+/**
+ * Builds the ordered list of columns (value + ids) for the board model.
+ *
+ * Column order: uncategorized first, then effectiveOrder, then any selectOption ids not yet in order.
+ * Each entry gets the ids from effectiveByColumn for that column (or empty).
+ *
+ * @param effectiveOrder - Column order from arrangement (or previous merge).
+ * @param effectiveByColumn - Per-column card id order from arrangement.
+ * @param selectOptions - Defines valid column ids; any missing from order are appended.
+ * @returns ColumnStructure array in display order.
+ */
+export const computeColumnStructure = (
+  effectiveOrder: string[],
+  effectiveByColumn: Record<string, { ids: string[]; hidden?: boolean }>,
+  selectOptions: SelectOption[],
+): ColumnStructure[] => {
+  const order = [...effectiveOrder];
+  if (!order.includes(UNCATEGORIZED_VALUE)) {
+    order.unshift(UNCATEGORIZED_VALUE);
+  }
+
+  for (const opt of selectOptions) {
+    if (opt.id !== UNCATEGORIZED_VALUE && !order.includes(opt.id)) {
+      order.push(opt.id);
+    }
+  }
+
+  return order.map((columnValue) => ({
+    columnValue,
+    ids: effectiveByColumn[columnValue]?.ids ?? [],
+  }));
+};
+
+/**
+ * Orders items for a single column: partition by saved order vs new, sort by orderMap, concatenate.
+ * Uses explicit null/undefined check for itemColumn so empty string is handled consistently.
+ *
+ * @param items - All items to filter.
+ * @param ids - Saved id order for this column.
+ * @param columnValue - Column id (e.g. UNCATEGORIZED_VALUE or option id).
+ * @param pivotPath - Item property key for column value (undefined = no pivot).
+ * @param validColumnValues - Set of valid option ids.
+ * @returns Items belonging to this column in display order.
+ */
+export const orderItemsInColumn = <T extends BaseKanbanItem>(
+  items: T[],
+  ids: string[],
+  columnValue: string,
+  pivotPath: string | undefined,
+  validColumnValues: Set<string>,
+): T[] => {
+  const orderMap = new Map(ids.map((id, index) => [id, index]));
+  const cardsWithExistingOrder: T[] = [];
+  const newCards: T[] = [];
+
+  for (const item of items) {
+    const itemColumn = pivotPath !== undefined ? (item[pivotPath as keyof T] as string | undefined) : undefined;
+    const isValidColumn = itemColumn != null && validColumnValues.has(itemColumn);
+    const belongsInColumn = columnValue === UNCATEGORIZED_VALUE ? !isValidColumn : itemColumn === columnValue;
+
+    if (belongsInColumn) {
+      (orderMap.has(item.id) ? cardsWithExistingOrder : newCards).push(item);
+    }
+  }
+
+  cardsWithExistingOrder.sort((a, b) => {
+    const indexA = orderMap.get(a.id) ?? Infinity;
+    const indexB = orderMap.get(b.id) ?? Infinity;
+    return indexA - indexB;
+  });
+
+  return [...cardsWithExistingOrder, ...newCards];
+};
+
+/**
+ * Computes the full item arrangement for the board: one entry per column with items in display order.
+ *
+ * Columns follow selectOptions order (uncategorized first, then each option). Within each column,
+ * cards that appear in the kanban's saved arrangement keep that order; any other cards in that
+ * column are appended after them.
+ *
+ * @param object - Kanban object whose arrangement holds per-column id order.
+ * @param items - All items to distribute into columns.
+ * @param pivotPath - Optional item property key whose value is the column id (e.g. status, priority).
+ * @param selectOptions - Defines valid column ids and their display order.
+ * @returns Array of { columnValue, cards } in column order, with cards ordered as above.
+ */
+export const computeItemArrangement = <T extends BaseKanbanItem = BaseKanbanItem>({
+  object,
+  items,
+  pivotPath,
+  selectOptions,
+}: {
+  object: Kanban.Kanban;
+  items: T[];
+  pivotPath?: string;
+  selectOptions: SelectOption[];
+}): ArrangedCards<T> => {
+  const validColumnValues = new Set(selectOptions.map((opt) => opt.id));
+  const byColumn = getOrderByColumnFromArrangement(object?.arrangement);
+
+  // Column order: uncategorized first, then each select option (skip uncategorized if duplicated).
+  const columnEntries = [
+    { columnValue: UNCATEGORIZED_VALUE, ids: byColumn[UNCATEGORIZED_VALUE]?.ids ?? [] },
+    ...selectOptions
+      .filter((opt) => opt.id !== UNCATEGORIZED_VALUE)
+      .map((opt) => ({ columnValue: opt.id, ids: byColumn[opt.id]?.ids ?? [] })),
+  ];
+
+  return columnEntries.map(({ columnValue, ids }) => ({
+    columnValue,
+    cards: orderItemsInColumn(items, ids, columnValue, pivotPath, validColumnValues),
+  }));
+};

package/src/util/index.ts

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

package/dist/lib/browser/blueprint-definition-UYVX622Q.mjs

@@ -1,28 +0,0 @@
-// src/capabilities/blueprint-definition.ts
-import { Capabilities, contributes } from "@dxos/app-framework";
-import { Blueprint, Template } from "@dxos/blueprints";
-import { trim } from "@dxos/util";
-var functions = [];
-var tools = [];
-var blueprint_definition_default = (() => {
-  return [
-    contributes(Capabilities.Functions, functions),
-    contributes(Capabilities.BlueprintDefinition, Blueprint.make({
-      key: "dxos.org/blueprint/kanban",
-      name: "Kanban",
-      tools: Blueprint.toolDefinitions({
-        functions,
-        tools
-      }),
-      instructions: Template.make({
-        source: trim`
-            You can create and update kanban boards to show data in sorted columns defined by schema.
-          `
-      })
-    }))
-  ];
-});
-export {
-  blueprint_definition_default as default
-};
-//# sourceMappingURL=blueprint-definition-UYVX622Q.mjs.map

package/dist/lib/browser/blueprint-definition-UYVX622Q.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/capabilities/blueprint-definition.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capabilities, contributes } from '@dxos/app-framework';\nimport { Blueprint, Template } from '@dxos/blueprints';\nimport { type FunctionDefinition } from '@dxos/functions';\nimport { trim } from '@dxos/util';\n\nconst functions: FunctionDefinition[] = [];\nconst tools: string[] = [];\n\nexport default () => {\n  return [\n    contributes(Capabilities.Functions, functions),\n    contributes(\n      Capabilities.BlueprintDefinition,\n      Blueprint.make({\n        key: 'dxos.org/blueprint/kanban',\n        name: 'Kanban',\n        tools: Blueprint.toolDefinitions({ functions, tools }),\n        instructions: Template.make({\n          source: trim`\n            You can create and update kanban boards to show data in sorted columns defined by schema.\n          `,\n        }),\n      }),\n    ),\n  ];\n};\n"],
-  "mappings": ";AAIA,SAASA,cAAcC,mBAAmB;AAC1C,SAASC,WAAWC,gBAAgB;AAEpC,SAASC,YAAY;AAErB,IAAMC,YAAkC,CAAA;AACxC,IAAMC,QAAkB,CAAA;AAExB,IAAA,gCAAe,MAAA;AACb,SAAO;IACLC,YAAYC,aAAaC,WAAWJ,SAAAA;IACpCE,YACEC,aAAaE,qBACbC,UAAUC,KAAK;MACbC,KAAK;MACLC,MAAM;MACNR,OAAOK,UAAUI,gBAAgB;QAAEV;QAAWC;MAAM,CAAA;MACpDU,cAAcC,SAASL,KAAK;QAC1BM,QAAQC;;;MAGV,CAAA;IACF,CAAA,CAAA;;AAGN;",
-  "names": ["Capabilities", "contributes", "Blueprint", "Template", "trim", "functions", "tools", "contributes", "Capabilities", "Functions", "BlueprintDefinition", "Blueprint", "make", "key", "name", "toolDefinitions", "instructions", "Template", "source", "trim"]
-}

package/dist/lib/browser/chunk-3UDST345.mjs

@@ -1,85 +0,0 @@
-// src/types/schema.ts
-import * as Schema from "effect/Schema";
-import { SpaceSchema } from "@dxos/react-client/echo";
-import { DataType, FieldSchema, TypenameAnnotationId } from "@dxos/schema";
-
-// src/meta.ts
-import { trim } from "@dxos/util";
-var meta = {
-  id: "dxos.org/plugin/kanban",
-  name: "Kanban",
-  description: trim`
-    Visual project management using customizable kanban boards to track workflow progress.
-    Organize table data into columns, drag and drop items between stages, and trigger automations based on status changes.
-  `,
-  icon: "ph--kanban--regular",
-  iconHue: "green",
-  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-kanban",
-  screenshots: [
-    "https://dxos.network/plugin-details-kanban-dark.png"
-  ]
-};
-
-// src/types/schema.ts
-var PivotColumnAnnotationId = Symbol.for("@dxos/plugin-kanban/annotation/PivotColumn");
-var CreateKanbanSchema = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  typename: Schema.optional(Schema.String.annotations({
-    [TypenameAnnotationId]: [
-      "used-static",
-      "dynamic"
-    ],
-    title: "Select card record type (leave empty to start fresh)"
-  })),
-  initialPivotColumn: Schema.optional(Schema.String.annotations({
-    [PivotColumnAnnotationId]: true,
-    title: "Pivot column"
-  }))
-});
-(function(KanbanAction2) {
-  const KANBAN_ACTION = `${meta.id}/action`;
-  class Create extends Schema.TaggedClass()(`${KANBAN_ACTION}/create`, {
-    input: Schema.extend(Schema.Struct({
-      space: SpaceSchema
-    }), CreateKanbanSchema),
-    output: Schema.Struct({
-      object: DataType.View
-    })
-  }) {
-  }
-  KanbanAction2.Create = Create;
-  class DeleteCardField extends Schema.TaggedClass()(`${KANBAN_ACTION}/delete-card-field`, {
-    input: Schema.Struct({
-      view: DataType.View,
-      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
-  }) {
-  }
-  KanbanAction2.DeleteCardField = DeleteCardField;
-  class DeleteCard extends Schema.TaggedClass()(`${KANBAN_ACTION}/delete-card`, {
-    input: Schema.Struct({
-      card: Schema.Any
-    }),
-    output: Schema.Void
-  }) {
-  }
-  KanbanAction2.DeleteCard = DeleteCard;
-})(KanbanAction || (KanbanAction = {}));
-var KanbanAction;
-
-export {
-  meta,
-  PivotColumnAnnotationId,
-  CreateKanbanSchema,
-  KanbanAction
-};
-//# sourceMappingURL=chunk-3UDST345.mjs.map

package/dist/lib/browser/chunk-3UDST345.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/schema.ts", "../../../src/meta.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { SpaceSchema } from '@dxos/react-client/echo';\nimport { DataType, FieldSchema, TypenameAnnotationId } from '@dxos/schema';\n\nimport { meta } from '../meta';\n\n/**\n * Kanban data model.\n * A Kanban board is a collection of columns, each of which contains a collection of items.\n * The layout of columns and items is controlled by models.\n * The underlying data model may be represented by direct object relationships\n * (e.g., a column object containing an array of ordered items) or projections constructed\n * by the model (e.g., a query of items based on metadata within a column object).\n */\n\n// TODO(wittjosiah): Factor out?\nexport const PivotColumnAnnotationId = Symbol.for('@dxos/plugin-kanban/annotation/PivotColumn');\n\nexport const CreateKanbanSchema = Schema.Struct({\n  name: Schema.optional(Schema.String),\n  typename: Schema.optional(\n    Schema.String.annotations({\n      [TypenameAnnotationId]: ['used-static', 'dynamic'],\n      title: 'Select card record type (leave empty to start fresh)',\n    }),\n  ),\n  initialPivotColumn: Schema.optional(\n    Schema.String.annotations({\n      [PivotColumnAnnotationId]: true,\n      title: 'Pivot column',\n    }),\n  ),\n});\n\nexport namespace KanbanAction {\n  const KANBAN_ACTION = `${meta.id}/action`;\n\n  export class Create extends Schema.TaggedClass<Create>()(`${KANBAN_ACTION}/create`, {\n    input: Schema.extend(Schema.Struct({ space: SpaceSchema }), CreateKanbanSchema),\n    output: Schema.Struct({\n      object: DataType.View,\n    }),\n  }) {}\n\n  export class DeleteCardField extends Schema.TaggedClass<DeleteCardField>()(`${KANBAN_ACTION}/delete-card-field`, {\n    input: Schema.Struct({\n      view: DataType.View,\n      fieldId: Schema.String,\n      // TODO(wittjosiah): Separate fields for undo data?\n      deletionData: Schema.optional(\n        Schema.Struct({\n          field: FieldSchema,\n          // TODO(wittjosiah): This creates a type error.\n          // props: PropertySchema,\n          props: Schema.Any,\n          index: Schema.Number,\n        }),\n      ),\n    }),\n    output: Schema.Void,\n  }) {}\n\n  export class DeleteCard extends Schema.TaggedClass<DeleteCard>()(`${KANBAN_ACTION}/delete-card`, {\n    input: Schema.Struct({\n      card: Schema.Any, // The card object to delete\n    }),\n    output: Schema.Void,\n  }) {}\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { type PluginMeta } from '@dxos/app-framework';\nimport { trim } from '@dxos/util';\n\nexport const meta: PluginMeta = {\n  id: 'dxos.org/plugin/kanban',\n  name: 'Kanban',\n  description: trim`\n    Visual project management using customizable kanban boards to track workflow progress.\n    Organize table data into columns, drag and drop items between stages, and trigger automations based on status changes.\n  `,\n  icon: 'ph--kanban--regular',\n  iconHue: 'green',\n  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-kanban',\n  screenshots: ['https://dxos.network/plugin-details-kanban-dark.png'],\n};\n"],
-  "mappings": ";AAIA,YAAYA,YAAY;AAExB,SAASC,mBAAmB;AAC5B,SAASC,UAAUC,aAAaC,4BAA4B;;;ACF5D,SAASC,YAAY;AAEd,IAAMC,OAAmB;EAC9BC,IAAI;EACJC,MAAM;EACNC,aAAaC;;;;EAIbC,MAAM;EACNC,SAAS;EACTC,QAAQ;EACRC,aAAa;IAAC;;AAChB;;;ADGO,IAAMC,0BAA0BC,OAAOC,IAAI,4CAAA;AAE3C,IAAMC,qBAA4BC,cAAO;EAC9CC,MAAaC,gBAAgBC,aAAM;EACnCC,UAAiBF,gBACRC,cAAOE,YAAY;IACxB,CAACC,oBAAAA,GAAuB;MAAC;MAAe;;IACxCC,OAAO;EACT,CAAA,CAAA;EAEFC,oBAA2BN,gBAClBC,cAAOE,YAAY;IACxB,CAACT,uBAAAA,GAA0B;IAC3BW,OAAO;EACT,CAAA,CAAA;AAEJ,CAAA;UAEiBE,eAAAA;AACf,QAAMC,gBAAgB,GAAGC,KAAKC,EAAE;EAEzB,MAAMC,eAAsBC,mBAAW,EAAW,GAAGJ,aAAAA,WAAwB;IAClFK,OAAcC,cAAchB,cAAO;MAAEiB,OAAOC;IAAY,CAAA,GAAInB,kBAAAA;IAC5DoB,QAAenB,cAAO;MACpBoB,QAAQC,SAASC;IACnB,CAAA;EACF,CAAA,EAAA;EAAI;gBALST,SAAAA;EAON,MAAMU,wBAA+BT,mBAAW,EAAoB,GAAGJ,aAAAA,sBAAmC;IAC/GK,OAAcf,cAAO;MACnBwB,MAAMH,SAASC;MACfG,SAAgBtB;;MAEhBuB,cAAqBxB,gBACZF,cAAO;QACZ2B,OAAOC;;;QAGPC,OAAcC;QACdC,OAAcC;MAChB,CAAA,CAAA;IAEJ,CAAA;IACAb,QAAec;EACjB,CAAA,EAAA;EAAI;gBAhBSV,kBAAAA;EAkBN,MAAMW,mBAA0BpB,mBAAW,EAAe,GAAGJ,aAAAA,gBAA6B;IAC/FK,OAAcf,cAAO;MACnBmC,MAAaL;IACf,CAAA;IACAX,QAAec;EACjB,CAAA,EAAA;EAAI;gBALSC,aAAAA;AAMf,GAlCiBzB,iBAAAA,eAAAA,CAAAA,EAAAA;;",
-  "names": ["Schema", "SpaceSchema", "DataType", "FieldSchema", "TypenameAnnotationId", "trim", "meta", "id", "name", "description", "trim", "icon", "iconHue", "source", "screenshots", "PivotColumnAnnotationId", "Symbol", "for", "CreateKanbanSchema", "Struct", "name", "optional", "String", "typename", "annotations", "TypenameAnnotationId", "title", "initialPivotColumn", "KanbanAction", "KANBAN_ACTION", "meta", "id", "Create", "TaggedClass", "input", "extend", "space", "SpaceSchema", "output", "object", "DataType", "View", "DeleteCardField", "view", "fieldId", "deletionData", "field", "FieldSchema", "props", "Any", "index", "Number", "Void", "DeleteCard", "card"]
-}

package/dist/lib/browser/intent-resolver-VVBNS2TO.mjs

@@ -1,111 +0,0 @@
-import {
-  KanbanAction,
-  meta
-} from "./chunk-3UDST345.mjs";
-
-// src/capabilities/intent-resolver.ts
-import { Capabilities, contributes, createResolver } from "@dxos/app-framework";
-import { invariant } from "@dxos/invariant";
-import { ClientCapabilities } from "@dxos/plugin-client";
-import { getSpace } from "@dxos/react-client/echo";
-import { Kanban } from "@dxos/react-ui-kanban/types";
-import { ProjectionModel, getTypenameFromQuery } from "@dxos/schema";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-kanban/src/capabilities/intent-resolver.ts";
-var intent_resolver_default = ((context) => contributes(Capabilities.IntentResolver, [
-  createResolver({
-    intent: KanbanAction.Create,
-    resolve: async ({ space, name, typename, initialPivotColumn }) => {
-      const client = context.getCapability(ClientCapabilities.Client);
-      const { view } = await Kanban.makeView({
-        client,
-        space,
-        name,
-        typename,
-        pivotFieldName: initialPivotColumn
-      });
-      return {
-        data: {
-          object: view
-        }
-      };
-    }
-  }),
-  createResolver({
-    intent: KanbanAction.DeleteCardField,
-    resolve: async ({ view, fieldId, deletionData }, undo) => {
-      const schema = getSpace(view)?.db.schemaRegistry.getSchema(getTypenameFromQuery(view.query.ast));
-      invariant(schema, void 0, {
-        F: __dxlog_file,
-        L: 35,
-        S: void 0,
-        A: [
-          "schema",
-          ""
-        ]
-      });
-      const projection = new ProjectionModel(schema.jsonSchema, view.projection);
-      if (!undo) {
-        const { deleted, index } = projection.deleteFieldProjection(fieldId);
-        return {
-          undoable: {
-            message: [
-              "card field deleted label",
-              {
-                ns: meta.id
-              }
-            ],
-            data: {
-              deletionData: {
-                ...deleted,
-                index
-              }
-            }
-          }
-        };
-      } else if (undo && deletionData) {
-        const { field, props, index } = deletionData;
-        projection.setFieldProjection({
-          field,
-          props
-        }, index);
-      }
-    }
-  }),
-  createResolver({
-    intent: KanbanAction.DeleteCard,
-    resolve: ({ card }, undo) => {
-      const space = getSpace(card);
-      invariant(space, void 0, {
-        F: __dxlog_file,
-        L: 56,
-        S: void 0,
-        A: [
-          "space",
-          ""
-        ]
-      });
-      if (!undo) {
-        space.db.remove(card);
-        return {
-          undoable: {
-            message: [
-              "card deleted label",
-              {
-                ns: meta.id
-              }
-            ],
-            data: {
-              card
-            }
-          }
-        };
-      } else {
-        space.db.add(card);
-      }
-    }
-  })
-]));
-export {
-  intent_resolver_default as default
-};
-//# sourceMappingURL=intent-resolver-VVBNS2TO.mjs.map