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

package/dist/lib/node-esm/chunk-4AWDHQVY.mjs

@@ -0,0 +1,214 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/types/constants.ts
+var UNCATEGORIZED_VALUE = "__uncategorized__";
+var UNCATEGORIZED_ATTRIBUTES = {
+  title: "Uncategorized",
+  color: "neutral"
+};
+
+// src/types/Kanban.ts
+var Kanban_exports = {};
+__export(Kanban_exports, {
+  Arrangement: () => Arrangement,
+  Kanban: () => Kanban,
+  make: () => make
+});
+import * as Schema from "effect/Schema";
+import { Obj, Ref, Type } from "@dxos/echo";
+import { View } from "@dxos/echo";
+import { FormInputAnnotation, LabelAnnotation } from "@dxos/echo/internal";
+import { ViewAnnotation } from "@dxos/schema";
+var ArrangementColumnEntry = Schema.Struct({
+  ids: Schema.Array(Obj.ID),
+  hidden: Schema.optional(Schema.Boolean)
+});
+var ArrangementColumns = Schema.Record({
+  key: Schema.String,
+  value: ArrangementColumnEntry
+}).pipe(FormInputAnnotation.set(false));
+var Arrangement = Schema.Struct({
+  order: Schema.Array(Schema.String).pipe(FormInputAnnotation.set(false)),
+  columns: ArrangementColumns
+}).pipe(FormInputAnnotation.set(false));
+var Kanban = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
+  /** Column display order and per-column card ids. */
+  arrangement: Arrangement
+}).pipe(Type.object({
+  typename: "dxos.org/type/Kanban",
+  version: "0.3.0"
+}), LabelAnnotation.set([
+  "name"
+]), ViewAnnotation.set(true));
+var make = (props) => {
+  const { name, view, arrangement } = props;
+  const order = arrangement?.order ?? [];
+  const columns = arrangement?.columns ?? {};
+  return Obj.make(Kanban, {
+    name,
+    view: Ref.make(view),
+    arrangement: {
+      order,
+      columns
+    }
+  });
+};
+
+// src/types/schema.ts
+import * as Schema2 from "effect/Schema";
+import { Capability } from "@dxos/app-framework";
+import { View as View2 } from "@dxos/echo";
+import { Operation } from "@dxos/operation";
+import { TypeInputOptionsAnnotation } from "@dxos/plugin-space/types";
+
+// 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 = /* @__PURE__ */ Symbol.for("@dxos/plugin-kanban/annotation/PivotColumn");
+var SettingsSchema = Schema2.Struct({
+  columnFieldId: Schema2.String.annotations({
+    title: "Column field"
+  })
+});
+var CreateKanbanSchema = Schema2.Struct({
+  name: Schema2.optional(Schema2.String),
+  // TODO(wittjosiah): This should be a query input instead.
+  typename: Schema2.String.pipe(Schema2.annotations({
+    title: "Select card type"
+  }), TypeInputOptionsAnnotation.set({
+    location: [
+      "database",
+      "runtime"
+    ],
+    kind: [
+      "user"
+    ],
+    registered: [
+      "registered"
+    ]
+  }), Schema2.optional),
+  initialPivotColumn: Schema2.optional(Schema2.String.annotations({
+    [PivotColumnAnnotationId]: true,
+    title: "Pivot column"
+  }))
+});
+var KANBAN_OPERATION = `${meta.id}/operation`;
+(function(KanbanOperation2) {
+  KanbanOperation2.DeleteCardFieldOutput = Schema2.Struct({
+    field: View2.FieldSchema.annotations({
+      description: "The deleted field schema."
+    }),
+    props: Schema2.Any.annotations({
+      description: "The deleted field properties."
+    }),
+    index: Schema2.Number.annotations({
+      description: "The index the field was at."
+    })
+  });
+  KanbanOperation2.DeleteCardField = Operation.make({
+    meta: {
+      key: `${KANBAN_OPERATION}/delete-card-field`,
+      name: "Delete Card Field"
+    },
+    services: [
+      Capability.Service
+    ],
+    schema: {
+      input: Schema2.Struct({
+        view: View2.View,
+        fieldId: Schema2.String
+      }),
+      output: KanbanOperation2.DeleteCardFieldOutput
+    }
+  });
+  KanbanOperation2.DeleteCardOutput = Schema2.Struct({
+    card: Schema2.Any.annotations({
+      description: "The deleted card."
+    })
+  });
+  KanbanOperation2.DeleteCard = Operation.make({
+    meta: {
+      key: `${KANBAN_OPERATION}/delete-card`,
+      name: "Delete Card"
+    },
+    schema: {
+      input: Schema2.Struct({
+        card: Schema2.Any
+      }),
+      output: KanbanOperation2.DeleteCardOutput
+    }
+  });
+  KanbanOperation2.RestoreCardField = Operation.make({
+    meta: {
+      key: `${KANBAN_OPERATION}/restore-card-field`,
+      name: "Restore Card Field"
+    },
+    services: [
+      Capability.Service
+    ],
+    schema: {
+      input: Schema2.Struct({
+        view: View2.View.annotations({
+          description: "The view to restore the field to."
+        }),
+        field: View2.FieldSchema.annotations({
+          description: "The field schema to restore."
+        }),
+        props: Schema2.Any.annotations({
+          description: "The field properties to restore."
+        }),
+        index: Schema2.Number.annotations({
+          description: "The index to restore the field at."
+        })
+      }),
+      output: Schema2.Void
+    }
+  });
+  KanbanOperation2.RestoreCard = Operation.make({
+    meta: {
+      key: `${KANBAN_OPERATION}/restore-card`,
+      name: "Restore Card"
+    },
+    schema: {
+      input: Schema2.Struct({
+        card: Schema2.Any.annotations({
+          description: "The card to restore."
+        })
+      }),
+      output: Schema2.Void
+    }
+  });
+})(KanbanOperation || (KanbanOperation = {}));
+var KanbanOperation;
+
+export {
+  meta,
+  UNCATEGORIZED_VALUE,
+  UNCATEGORIZED_ATTRIBUTES,
+  Kanban_exports,
+  PivotColumnAnnotationId,
+  SettingsSchema,
+  CreateKanbanSchema,
+  KanbanOperation
+};
+//# sourceMappingURL=chunk-4AWDHQVY.mjs.map

package/dist/lib/node-esm/chunk-4AWDHQVY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/constants.ts", "../../../src/types/Kanban.ts", "../../../src/types/schema.ts", "../../../src/meta.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport const UNCATEGORIZED_VALUE = '__uncategorized__' as const;\nexport const UNCATEGORIZED_ATTRIBUTES = {\n  title: 'Uncategorized',\n  color: 'neutral',\n} as const;\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Obj, Ref, Type } from '@dxos/echo';\nimport { View } from '@dxos/echo';\nimport { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';\nimport { ViewAnnotation } from '@dxos/schema';\n\n/** Per-column entry (ids order, optional hidden). */\nconst ArrangementColumnEntry = Schema.Struct({\n  ids: Schema.Array(Obj.ID),\n  hidden: Schema.optional(Schema.Boolean),\n});\n\n/** Keyed by columnValue. */\nconst ArrangementColumns = Schema.Record({\n  key: Schema.String,\n  value: ArrangementColumnEntry,\n}).pipe(FormInputAnnotation.set(false));\n\n/** Column order and per-column card ids. */\nexport const Arrangement = Schema.Struct({\n  order: Schema.Array(Schema.String).pipe(FormInputAnnotation.set(false)),\n  columns: ArrangementColumns,\n}).pipe(FormInputAnnotation.set(false));\n\nexport type Arrangement = Schema.Schema.Type<typeof Arrangement>;\n\nexport const Kanban = Schema.Struct({\n  name: Schema.optional(Schema.String),\n\n  view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),\n\n  /** Column display order and per-column card ids. */\n  arrangement: Arrangement,\n}).pipe(\n  Type.object({\n    typename: 'dxos.org/type/Kanban',\n    version: '0.3.0',\n  }),\n  LabelAnnotation.set(['name']),\n  ViewAnnotation.set(true),\n);\n\n/** Instance type; use Kanban.Kanban in type position so namespace has .Kanban as type and .KanbanSchema as schema. */\nexport interface Kanban extends Schema.Schema.Type<typeof Kanban> {}\n\ntype MakeProps = Omit<Partial<Obj.MakeProps<typeof Kanban>>, 'view'> & {\n  view: View.View;\n};\n\n/**\n * Make a kanban as a view of a data set.\n */\nexport const make = (props: MakeProps): Kanban => {\n  const { name, view, arrangement } = props;\n  const order = arrangement?.order ?? [];\n  const columns = arrangement?.columns ?? {};\n  return Obj.make(Kanban, {\n    name,\n    view: Ref.make(view),\n    arrangement: { order, columns },\n  });\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Capability } from '@dxos/app-framework';\nimport { View } from '@dxos/echo';\nimport { Operation } from '@dxos/operation';\nimport { TypeInputOptionsAnnotation } from '@dxos/plugin-space/types';\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 SettingsSchema = Schema.Struct({\n  columnFieldId: Schema.String.annotations({\n    title: 'Column field',\n  }),\n});\n\nexport const CreateKanbanSchema = Schema.Struct({\n  name: Schema.optional(Schema.String),\n  // TODO(wittjosiah): This should be a query input instead.\n  typename: Schema.String.pipe(\n    Schema.annotations({ title: 'Select card type' }),\n    TypeInputOptionsAnnotation.set({\n      location: ['database', 'runtime'],\n      kind: ['user'],\n      registered: ['registered'],\n    }),\n    Schema.optional,\n  ),\n  initialPivotColumn: Schema.optional(\n    Schema.String.annotations({\n      [PivotColumnAnnotationId]: true,\n      title: 'Pivot column',\n    }),\n  ),\n});\n\nconst KANBAN_OPERATION = `${meta.id}/operation`;\n\nexport namespace KanbanOperation {\n  export const DeleteCardFieldOutput = Schema.Struct({\n    field: View.FieldSchema.annotations({ description: 'The deleted field schema.' }),\n    props: Schema.Any.annotations({ description: 'The deleted field properties.' }),\n    index: Schema.Number.annotations({ description: 'The index the field was at.' }),\n  });\n\n  export type DeleteCardFieldOutput = Schema.Schema.Type<typeof DeleteCardFieldOutput>;\n\n  export const DeleteCardField = Operation.make({\n    meta: { key: `${KANBAN_OPERATION}/delete-card-field`, name: 'Delete Card Field' },\n    services: [Capability.Service],\n    schema: {\n      input: Schema.Struct({\n        view: View.View,\n        fieldId: Schema.String,\n      }),\n      output: DeleteCardFieldOutput,\n    },\n  });\n\n  export const DeleteCardOutput = Schema.Struct({\n    card: Schema.Any.annotations({ description: 'The deleted card.' }),\n  });\n\n  export type DeleteCardOutput = Schema.Schema.Type<typeof DeleteCardOutput>;\n\n  export const DeleteCard = Operation.make({\n    meta: { key: `${KANBAN_OPERATION}/delete-card`, name: 'Delete Card' },\n    schema: {\n      input: Schema.Struct({\n        card: Schema.Any,\n      }),\n      output: DeleteCardOutput,\n    },\n  });\n\n  /**\n   * Restore a deleted card field (inverse of DeleteCardField).\n   */\n  export const RestoreCardField = Operation.make({\n    meta: { key: `${KANBAN_OPERATION}/restore-card-field`, name: 'Restore Card Field' },\n    services: [Capability.Service],\n    schema: {\n      input: Schema.Struct({\n        view: View.View.annotations({ description: 'The view to restore the field to.' }),\n        field: View.FieldSchema.annotations({ description: 'The field schema to restore.' }),\n        props: Schema.Any.annotations({ description: 'The field properties to restore.' }),\n        index: Schema.Number.annotations({ description: 'The index to restore the field at.' }),\n      }),\n      output: Schema.Void,\n    },\n  });\n\n  /**\n   * Restore a deleted card (inverse of DeleteCard).\n   */\n  export const RestoreCard = Operation.make({\n    meta: { key: `${KANBAN_OPERATION}/restore-card`, name: 'Restore Card' },\n    schema: {\n      input: Schema.Struct({\n        card: Schema.Any.annotations({ description: 'The card to restore.' }),\n      }),\n      output: Schema.Void,\n    },\n  });\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { type Plugin } from '@dxos/app-framework';\nimport { trim } from '@dxos/util';\n\nexport const meta: Plugin.Meta = {\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": "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",
+  "names": ["UNCATEGORIZED_VALUE", "UNCATEGORIZED_ATTRIBUTES", "title", "color", "Schema", "Obj", "Ref", "Type", "View", "FormInputAnnotation", "LabelAnnotation", "ViewAnnotation", "ArrangementColumnEntry", "Struct", "ids", "Array", "Obj", "ID", "hidden", "optional", "Boolean", "ArrangementColumns", "Record", "key", "String", "value", "pipe", "FormInputAnnotation", "set", "Arrangement", "order", "columns", "Kanban", "name", "view", "Ref", "View", "arrangement", "Type", "object", "typename", "version", "LabelAnnotation", "ViewAnnotation", "make", "props", "Schema", "Capability", "View", "Operation", "TypeInputOptionsAnnotation", "trim", "meta", "id", "name", "description", "trim", "icon", "iconHue", "source", "screenshots", "PivotColumnAnnotationId", "Symbol", "for", "SettingsSchema", "Struct", "columnFieldId", "String", "annotations", "title", "CreateKanbanSchema", "name", "optional", "typename", "pipe", "TypeInputOptionsAnnotation", "set", "location", "kind", "registered", "initialPivotColumn", "KANBAN_OPERATION", "meta", "id", "KanbanOperation", "DeleteCardFieldOutput", "field", "View", "FieldSchema", "description", "props", "Any", "index", "Number", "DeleteCardField", "Operation", "make", "key", "services", "Capability", "Service", "schema", "input", "view", "fieldId", "output", "DeleteCardOutput", "card", "DeleteCard", "RestoreCardField", "Void", "RestoreCard"]
+}

package/dist/lib/node-esm/chunk-CSL3HF2X.mjs

@@ -0,0 +1,386 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  UNCATEGORIZED_VALUE
+} from "./chunk-4AWDHQVY.mjs";
+
+// src/hooks/useEchoChangeCallback.ts
+import { useMemo } from "react";
+import { Obj } from "@dxos/echo";
+var createEchoChangeCallback = (kanban) => ({
+  kanban: (mutate) => Obj.change(kanban, (kanban2) => mutate(kanban2)),
+  setItemField: (item, field, value) => {
+    Obj.change(item, (item2) => {
+      item2[field] = value;
+    });
+  }
+});
+var useEchoChangeCallback = (kanban) => useMemo(() => kanban ? createEchoChangeCallback(kanban) : null, [
+  kanban
+]);
+
+// src/hooks/useProjectionModel.ts
+import { useState } from "react";
+import { JsonSchema, Type } from "@dxos/echo";
+import { log } from "@dxos/log";
+import { useAsyncEffect } from "@dxos/react-ui";
+import { ProjectionModel, createEchoChangeCallback as createEchoChangeCallback2 } from "@dxos/schema";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-kanban/src/hooks/useProjectionModel.ts";
+var useProjectionModel = (schema, kanban, registry) => {
+  const [projection, setProjection] = useState();
+  useAsyncEffect(async (controller) => {
+    if (!schema || !kanban) {
+      return;
+    }
+    try {
+      const view = await kanban.view.load();
+      if (controller.signal.aborted) {
+        return;
+      }
+      const jsonSchema = Type.isMutable(schema) ? schema.jsonSchema : JsonSchema.toJsonSchema(schema);
+      const change = createEchoChangeCallback2(view, Type.isMutable(schema) ? schema : void 0);
+      const projection2 = new ProjectionModel({
+        registry,
+        view,
+        baseSchema: jsonSchema,
+        change
+      });
+      projection2.normalizeView();
+      if (!controller.signal.aborted) {
+        setProjection(projection2);
+      }
+    } catch (err) {
+      log.catch(err, {
+        schema,
+        kanban
+      }, {
+        F: __dxlog_file,
+        L: 51,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  }, [
+    schema,
+    kanban,
+    registry
+  ]);
+  return projection;
+};
+
+// src/hooks/useKanbanBoardModel.ts
+import { Atom } from "@effect-atom/atom-react";
+import { useMemo as useMemo2 } from "react";
+import { Obj as Obj2 } from "@dxos/echo";
+import { AtomObj } from "@dxos/echo-atom";
+
+// src/util/arrangement.ts
+var getOrderFromArrangement = (arrangement) => {
+  const order = arrangement?.order;
+  if (order != null && order.length > 0) {
+    return [
+      ...order
+    ];
+  }
+  return [];
+};
+var getOrderByColumnFromArrangement = (arrangement) => {
+  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 !== void 0 && {
+          hidden: entry.hidden
+        }
+      }
+    ]));
+  }
+  return {};
+};
+var computeColumnStructure = (effectiveOrder, effectiveByColumn, selectOptions) => {
+  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 ?? []
+  }));
+};
+var orderItemsInColumn = (items, ids, columnValue, pivotPath, validColumnValues) => {
+  const orderMap = new Map(ids.map((id, index) => [
+    id,
+    index
+  ]));
+  const cardsWithExistingOrder = [];
+  const newCards = [];
+  for (const item of items) {
+    const itemColumn = pivotPath !== void 0 ? item[pivotPath] : void 0;
+    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
+  ];
+};
+
+// src/hooks/useKanbanBoardModel.ts
+function useKanbanBoardModel(kanban, projection, itemsAtom, registry) {
+  const arrangementAtom = useMemo2(() => AtomObj.makeProperty(kanban, "arrangement"), [
+    kanban
+  ]);
+  const viewSnapshotAtom = useMemo2(() => kanban?.view ? AtomObj.make(kanban.view) : Atom.make(() => void 0), [
+    kanban?.view
+  ]);
+  const pivotFieldIdAtom = useMemo2(() => Atom.make((get) => get(viewSnapshotAtom)?.projection?.pivotFieldId), [
+    viewSnapshotAtom
+  ]);
+  const effectiveByColumnAtom = useMemo2(() => Atom.make((get) => getOrderByColumnFromArrangement(get(arrangementAtom))), [
+    arrangementAtom
+  ]);
+  const columnsAtom = useMemo2(() => Atom.make((get) => {
+    const pivotFieldId = get(pivotFieldIdAtom);
+    if (pivotFieldId === void 0) {
+      return [];
+    }
+    get(projection.fields);
+    const fieldProj = projection.tryGetFieldProjection(pivotFieldId);
+    if (!fieldProj) {
+      return [];
+    }
+    const selectOptions = fieldProj.props.options ?? [];
+    if (selectOptions.length === 0) {
+      return [];
+    }
+    const arrangement = get(arrangementAtom);
+    const order = getOrderFromArrangement(arrangement);
+    const byColumn = getOrderByColumnFromArrangement(arrangement);
+    return computeColumnStructure(order, byColumn, selectOptions);
+  }), [
+    pivotFieldIdAtom,
+    arrangementAtom,
+    projection
+  ]);
+  const columnArrangementAtomFamily = useMemo2(() => Atom.family((columnValue) => Atom.make((get) => {
+    const byColumn = get(effectiveByColumnAtom);
+    return {
+      columnValue,
+      ids: [
+        ...byColumn[columnValue]?.ids ?? []
+      ]
+    };
+  })), [
+    effectiveByColumnAtom
+  ]);
+  const itemsAtomFamily = useMemo2(() => Atom.family((columnValue) => Atom.make((get) => {
+    const columnArr = get(columnArrangementAtomFamily(columnValue));
+    const allItems = get(itemsAtom);
+    const pivotFieldId = get(pivotFieldIdAtom);
+    if (pivotFieldId === void 0) {
+      return [];
+    }
+    get(projection.fields);
+    const fieldProj = projection.tryGetFieldProjection(pivotFieldId);
+    if (!fieldProj) {
+      return [];
+    }
+    const selectOptions = fieldProj.props.options ?? [];
+    const pivotPath = fieldProj.props.property;
+    const validColumnValues = new Set(selectOptions.map((opt) => opt.id));
+    return orderItemsInColumn(allItems, columnArr.ids, columnValue, pivotPath, validColumnValues);
+  })), [
+    columnArrangementAtomFamily,
+    itemsAtom,
+    pivotFieldIdAtom,
+    projection
+  ]);
+  return useMemo2(() => ({
+    getColumnId: (data) => data.columnValue,
+    getItemId: (data) => data.id,
+    isColumn: (obj) => typeof obj === "object" && obj !== null && "columnValue" in obj && "ids" in obj,
+    // TODO(wittjosiah): This should be restricted to objects of the type of the kanban view.
+    isItem: (obj) => Obj2.isObject(obj),
+    columns: columnsAtom,
+    items: (column) => itemsAtomFamily(column.columnValue),
+    getColumns: () => registry.get(columnsAtom) ?? [],
+    getItems: (column) => registry.get(itemsAtomFamily(column.columnValue)) ?? []
+  }), [
+    columnsAtom,
+    itemsAtomFamily,
+    registry
+  ]);
+}
+
+// src/hooks/useKanbanColumnEventHandler.ts
+import { useMemo as useMemo3 } from "react";
+import { arrayMove } from "@dxos/util";
+function useKanbanColumnEventHandler({ id, model, projection, pivotFieldId, change }) {
+  return useMemo3(() => ({
+    id,
+    canDrop: ({ source }) => {
+      if (!projection) {
+        return false;
+      }
+      const data = source.data;
+      const columnValue = model.getColumnId(data);
+      return model.isColumn(source.data) && columnValue !== UNCATEGORIZED_VALUE && source.id !== UNCATEGORIZED_VALUE;
+    },
+    onDrop: ({ source, target }) => {
+      if (!projection || pivotFieldId === void 0) {
+        return;
+      }
+      const sourceColumnData = source.data;
+      const sourceColumnId = model.getColumnId(sourceColumnData);
+      if (sourceColumnId === UNCATEGORIZED_VALUE) {
+        return;
+      }
+      const currentColumns = model.getColumns();
+      const sourceIndex = currentColumns.findIndex((c) => model.getColumnId(c) === sourceColumnId);
+      if (sourceIndex === -1) {
+        return;
+      }
+      let targetIndex;
+      if (target?.type === "tile" || target?.type === "placeholder") {
+        targetIndex = typeof target.location === "number" ? Math.floor(target.location) : -1;
+      } else if (target?.type === "container") {
+        targetIndex = currentColumns.length;
+      } else {
+        return;
+      }
+      if (targetIndex < 0) {
+        return;
+      }
+      const currentColumnIds = currentColumns.map((c) => model.getColumnId(c));
+      const reorderedColumnIds = arrayMove([
+        ...currentColumnIds
+      ], sourceIndex, targetIndex);
+      const fieldProjection = projection.getFieldProjection(pivotFieldId);
+      const currentOptions = [
+        ...fieldProjection.props.options ?? []
+      ];
+      const optionsInNewOrder = reorderedColumnIds.map((columnId) => currentOptions.find((o) => o.id === columnId)).filter((o) => o != null);
+      projection.setFieldProjection({
+        ...fieldProjection,
+        props: {
+          ...fieldProjection.props,
+          options: optionsInNewOrder
+        }
+      });
+      change.kanban((kanban) => {
+        kanban.arrangement.order = reorderedColumnIds.filter((columnId) => columnId !== UNCATEGORIZED_VALUE);
+      });
+    }
+  }), [
+    id,
+    model,
+    projection,
+    pivotFieldId,
+    change
+  ]);
+}
+
+// src/hooks/useKanbanItemEventHandler.ts
+import { useMemo as useMemo4 } from "react";
+function findColumn(id, arrangement) {
+  return arrangement.find(({ columnValue, cards }) => columnValue === id || cards.some((card) => card.id === id));
+}
+function useKanbanItemEventHandler({ column, columnFieldPath, model, change }) {
+  return useMemo4(() => ({
+    id: column.columnValue,
+    canDrop: ({ source }) => model.isItem(source.data),
+    onTake: ({ source }, cb) => {
+      void cb(source.data);
+    },
+    onDrop: ({ source, target }) => {
+      const columns = model.getColumns();
+      const currentArrangement = columns.map((col) => ({
+        columnValue: col.columnValue,
+        cards: model.getItems(col) ?? []
+      }));
+      const sourceColumnInSnapshot = findColumn(source.id, currentArrangement);
+      if (!sourceColumnInSnapshot) {
+        return;
+      }
+      const workingArrangement = currentArrangement.map((col) => ({
+        columnValue: col.columnValue,
+        cards: [
+          ...col.cards
+        ]
+      }));
+      const sourceColumnInWorking = workingArrangement.find((c) => c.columnValue === sourceColumnInSnapshot.columnValue || c.cards.some((card) => card.id === source.id));
+      const targetColumnInWorking = workingArrangement.find((c) => c.columnValue === column.columnValue);
+      if (!sourceColumnInWorking || !targetColumnInWorking) {
+        return;
+      }
+      const sourceIndex = sourceColumnInWorking.cards.findIndex((card) => card.id === source.id);
+      if (sourceIndex === -1) {
+        return;
+      }
+      const [movedCard] = sourceColumnInWorking.cards.splice(sourceIndex, 1);
+      if (columnFieldPath !== void 0) {
+        const newValue = targetColumnInWorking.columnValue === UNCATEGORIZED_VALUE ? void 0 : targetColumnInWorking.columnValue;
+        change.setItemField(movedCard, columnFieldPath, newValue);
+      }
+      const existingTargetIndex = target?.type === "tile" ? targetColumnInWorking.cards.findIndex((card) => model.getItemId(card) === target.id) : -1;
+      const closestEdge = target?.type === "placeholder" && typeof target.location === "number" ? target.location <= targetColumnInWorking.cards.length / 2 ? "top" : "bottom" : "bottom";
+      let insertIndex;
+      if (target?.type === "placeholder" && typeof target.location === "number") {
+        insertIndex = Math.max(0, Math.min(targetColumnInWorking.cards.length, Math.floor(target.location)));
+      } else if (target?.type === "container" || existingTargetIndex === -1) {
+        insertIndex = targetColumnInWorking.cards.length;
+      } else if (sourceColumnInWorking.columnValue === targetColumnInWorking.columnValue) {
+        insertIndex = closestEdge === "bottom" ? existingTargetIndex + 1 : existingTargetIndex;
+        if (sourceIndex < existingTargetIndex) {
+          insertIndex -= 1;
+        }
+      } else {
+        insertIndex = closestEdge === "bottom" ? existingTargetIndex + 1 : existingTargetIndex;
+      }
+      targetColumnInWorking.cards.splice(insertIndex, 0, movedCard);
+      change.kanban((kanban) => {
+        kanban.arrangement = {
+          order: workingArrangement.map(({ columnValue }) => columnValue),
+          columns: Object.fromEntries(workingArrangement.map(({ columnValue, cards }) => [
+            columnValue,
+            {
+              ids: cards.map((c) => c.id)
+            }
+          ]))
+        };
+      });
+    }
+  }), [
+    column,
+    columnFieldPath,
+    model,
+    change
+  ]);
+}
+
+export {
+  useEchoChangeCallback,
+  useKanbanBoardModel,
+  useKanbanColumnEventHandler,
+  useKanbanItemEventHandler,
+  useProjectionModel
+};
+//# sourceMappingURL=chunk-CSL3HF2X.mjs.map