@dxos/plugin-kanban 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/src/types/schema.ts

@@ -2,12 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { SpaceSchema } from '@dxos/react-client/echo';
-import { DataType, FieldSchema, TypenameAnnotationId } from '@dxos/schema';
-
-import { KANBAN_PLUGIN } from '../meta';
+import { TypeInputOptionsAnnotation } from '@dxos/plugin-space';
 
 /**
  * Kanban data model.
@@ -21,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]: ['used-static', 'dynamic'],
-      title: 'Select card record type (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({
@@ -36,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: DataType.View,
-    }),
-  }) {}
-
-  export class DeleteCardField extends Schema.TaggedClass<DeleteCardField>()(`${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,
-  }) {}
-
-  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,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.update().
+ * 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.update() if needed. */
+  setItemField: (item: T, field: string, value: unknown) => void;
+};

package/src/util/arrangement.test.ts

@@ -0,0 +1,218 @@
+//
+// 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('treats non-array ids as empty (Automerge / corrupt layout)', ({ expect }) => {
+      const arrangement = {
+        order: [],
+        columns: { a: { ids: {} as unknown as string[] }, b: { ids: ['ok'] } },
+      };
+      const byColumn = getOrderByColumnFromArrangement(arrangement);
+      expect(byColumn.a.ids).toEqual([]);
+      expect(byColumn.b.ids).toEqual(['ok']);
+    });
+
+    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,177 @@
+//
+// 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 && Array.isArray(order) && 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]) => {
+        const rawIds = entry.ids;
+        const ids = Array.isArray(rawIds) ? [...rawIds] : [];
+        return [key, { 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). Columns whose entry has
+ * `hidden: true` are dropped from the result — currently only the
+ * "Uncategorized" column is toggleable from settings, but the filter is
+ * generic so any column can be hidden via the same flag.
+ *
+ * @param effectiveOrder - Column order from arrangement (or previous merge).
+ * @param effectiveByColumn - Per-column card id order + hidden flag 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
+    .filter((columnValue) => effectiveByColumn[columnValue]?.hidden !== true)
+    .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). Columns whose arrangement entry has
+  // `hidden: true` are dropped — same generic hide-by-column flag used
+  // by `computeColumnStructure`.
+  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 ?? [] })),
+  ].filter((entry) => byColumn[entry.columnValue]?.hidden !== true);
+
+  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-GFG7LX2C.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-GFG7LX2C.mjs.map

package/dist/lib/browser/blueprint-definition-GFG7LX2C.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,+BAAe,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-NCNNL74W.mjs

@@ -1,82 +0,0 @@
-// src/types/schema.ts
-import { Schema } from "effect";
-import { SpaceSchema } from "@dxos/react-client/echo";
-import { DataType, FieldSchema, TypenameAnnotationId } from "@dxos/schema";
-
-// src/meta.ts
-var KANBAN_PLUGIN = "dxos.org/plugin/kanban";
-var meta = {
-  id: KANBAN_PLUGIN,
-  name: "Kanban",
-  description: "Kanban allows you to explore Table data in sorted columns defined by your custom schema. You can use Kanbans to track progress or trigger custom automations when cards are moved from one state to another.",
-  icon: "ph--kanban--regular",
-  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 = `${KANBAN_PLUGIN}/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 {
-  KANBAN_PLUGIN,
-  meta,
-  PivotColumnAnnotationId,
-  CreateKanbanSchema,
-  KanbanAction
-};
-//# sourceMappingURL=chunk-NCNNL74W.mjs.map

package/dist/lib/browser/chunk-NCNNL74W.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 { Schema } from 'effect';\n\nimport { SpaceSchema } from '@dxos/react-client/echo';\nimport { DataType, FieldSchema, TypenameAnnotationId } from '@dxos/schema';\n\nimport { KANBAN_PLUGIN } 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 = `${KANBAN_PLUGIN}/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';\n\nexport const KANBAN_PLUGIN = 'dxos.org/plugin/kanban';\n\nexport const meta: PluginMeta = {\n  id: KANBAN_PLUGIN,\n  name: 'Kanban',\n  description:\n    'Kanban allows you to explore Table data in sorted columns defined by your custom schema. You can use Kanbans to track progress or trigger custom automations when cards are moved from one state to another.',\n  icon: 'ph--kanban--regular',\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,SAASA,cAAc;AAEvB,SAASC,mBAAmB;AAC5B,SAASC,UAAUC,aAAaC,4BAA4B;;;ACDrD,IAAMC,gBAAgB;AAEtB,IAAMC,OAAmB;EAC9BC,IAAIF;EACJG,MAAM;EACNC,aACE;EACFC,MAAM;EACNC,QAAQ;EACRC,aAAa;IAAC;;AAChB;;;ADKO,IAAMC,0BAA0BC,OAAOC,IAAI,4CAAA;AAE3C,IAAMC,qBAAqBC,OAAOC,OAAO;EAC9CC,MAAMF,OAAOG,SAASH,OAAOI,MAAM;EACnCC,UAAUL,OAAOG,SACfH,OAAOI,OAAOE,YAAY;IACxB,CAACC,oBAAAA,GAAuB;MAAC;MAAe;;IACxCC,OAAO;EACT,CAAA,CAAA;EAEFC,oBAAoBT,OAAOG,SACzBH,OAAOI,OAAOE,YAAY;IACxB,CAACV,uBAAAA,GAA0B;IAC3BY,OAAO;EACT,CAAA,CAAA;AAEJ,CAAA;UAEiBE,eAAAA;AACf,QAAMC,gBAAgB,GAAGC,aAAAA;EAElB,MAAMC,eAAeb,OAAOc,YAAW,EAAW,GAAGH,aAAAA,WAAwB;IAClFI,OAAOf,OAAOgB,OAAOhB,OAAOC,OAAO;MAAEgB,OAAOC;IAAY,CAAA,GAAInB,kBAAAA;IAC5DoB,QAAQnB,OAAOC,OAAO;MACpBmB,QAAQC,SAASC;IACnB,CAAA;EACF,CAAA,EAAA;EAAI;gBALST,SAAAA;EAON,MAAMU,wBAAwBvB,OAAOc,YAAW,EAAoB,GAAGH,aAAAA,sBAAmC;IAC/GI,OAAOf,OAAOC,OAAO;MACnBuB,MAAMH,SAASC;MACfG,SAASzB,OAAOI;;MAEhBsB,cAAc1B,OAAOG,SACnBH,OAAOC,OAAO;QACZ0B,OAAOC;;;QAGPC,OAAO7B,OAAO8B;QACdC,OAAO/B,OAAOgC;MAChB,CAAA,CAAA;IAEJ,CAAA;IACAb,QAAQnB,OAAOiC;EACjB,CAAA,EAAA;EAAI;gBAhBSV,kBAAAA;EAkBN,MAAMW,mBAAmBlC,OAAOc,YAAW,EAAe,GAAGH,aAAAA,gBAA6B;IAC/FI,OAAOf,OAAOC,OAAO;MACnBkC,MAAMnC,OAAO8B;IACf,CAAA;IACAX,QAAQnB,OAAOiC;EACjB,CAAA,EAAA;EAAI;gBALSC,aAAAA;AAMf,GAlCiBxB,iBAAAA,eAAAA,CAAAA,EAAAA;;",
-  "names": ["Schema", "SpaceSchema", "DataType", "FieldSchema", "TypenameAnnotationId", "KANBAN_PLUGIN", "meta", "id", "name", "description", "icon", "source", "screenshots", "PivotColumnAnnotationId", "Symbol", "for", "CreateKanbanSchema", "Schema", "Struct", "name", "optional", "String", "typename", "annotations", "TypenameAnnotationId", "title", "initialPivotColumn", "KanbanAction", "KANBAN_ACTION", "KANBAN_PLUGIN", "Create", "TaggedClass", "input", "extend", "space", "SpaceSchema", "output", "object", "DataType", "View", "DeleteCardField", "view", "fieldId", "deletionData", "field", "FieldSchema", "props", "Any", "index", "Number", "Void", "DeleteCard", "card"]
-}