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

package/dist/lib/neutral/containers/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/containers/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { type ComponentType, lazy } from 'react';\n\nexport const KanbanArticle: ComponentType<any> = lazy(() => import('./KanbanArticle'));\nexport const KanbanSettings: ComponentType<any> = lazy(() => import('./KanbanSettings'));\n"],
+  "mappings": ";;;AAIA,SAA6BA,YAAY;AAElC,IAAMC,gBAAoCD,KAAK,MAAM,OAAO,+BAAA,CAAA;AAC5D,IAAME,iBAAqCF,KAAK,MAAM,OAAO,gCAAA,CAAA;",
+  "names": ["lazy", "KanbanArticle", "KanbanSettings"]
+}

package/dist/lib/neutral/create-object-DKBSI46K.mjs

@@ -0,0 +1,40 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/create-object.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { Type } from "@dxos/echo";
+import { SpaceOperation } from "@dxos/plugin-space";
+import { SpaceCapabilities } from "@dxos/plugin-space";
+import { ViewModel } from "@dxos/schema";
+import { CreateKanbanSchema, Kanban } from "#types";
+var create_object_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+    id: Type.getTypename(Kanban.Kanban),
+    inputSchema: CreateKanbanSchema,
+    createObject: (props, options) => Effect.gen(function* () {
+      const object = yield* Effect.promise(async () => {
+        const { view } = await ViewModel.makeFromDatabase({
+          db: options.db,
+          typename: props.typename,
+          pivotFieldName: props.initialPivotColumn
+        });
+        return Kanban.make({
+          name: props.name,
+          view
+        });
+      });
+      return yield* Operation.invoke(SpaceOperation.AddObject, {
+        object,
+        target: options.target,
+        hidden: true,
+        targetNodeId: options.targetNodeId
+      });
+    })
+  });
+}));
+export {
+  create_object_default as default
+};
+//# sourceMappingURL=create-object-DKBSI46K.mjs.map

package/dist/lib/neutral/create-object-DKBSI46K.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/create-object.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { Operation } from '@dxos/compute';\nimport { Type } from '@dxos/echo';\nimport { SpaceOperation } from '@dxos/plugin-space';\nimport { SpaceCapabilities } from '@dxos/plugin-space';\nimport { ViewModel } from '@dxos/schema';\n\nimport { CreateKanbanSchema, Kanban } from '#types';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {\n      id: Type.getTypename(Kanban.Kanban),\n      inputSchema: CreateKanbanSchema,\n      createObject: (props, options) =>\n        Effect.gen(function* () {\n          const object = yield* Effect.promise(async () => {\n            const { view } = await ViewModel.makeFromDatabase({\n              db: options.db,\n              typename: props.typename,\n              pivotFieldName: props.initialPivotColumn,\n            });\n            return Kanban.make({ name: props.name, view });\n          });\n          return yield* Operation.invoke(SpaceOperation.AddObject, {\n            object,\n            target: options.target,\n            hidden: true,\n            targetNodeId: options.targetNodeId,\n          });\n        }),\n    });\n  }),\n);\n"],
+  "mappings": ";;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,iBAAiB;AAC1B,SAASC,YAAY;AACrB,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAClC,SAASC,iBAAiB;AAE1B,SAASC,oBAAoBC,cAAc;AAE3C,IAAA,wBAAeP,WAAWQ,WACjBC,kBAAW,aAAA;AAChB,SAAOT,WAAWU,YAAYN,kBAAkBO,mBAAmB;IACjEC,IAAIV,KAAKW,YAAYN,OAAOA,MAAM;IAClCO,aAAaR;IACbS,cAAc,CAACC,OAAOC,YACbC,WAAI,aAAA;AACT,YAAMC,SAAS,OAAcC,eAAQ,YAAA;AACnC,cAAM,EAAEC,KAAI,IAAK,MAAMhB,UAAUiB,iBAAiB;UAChDC,IAAIN,QAAQM;UACZC,UAAUR,MAAMQ;UAChBC,gBAAgBT,MAAMU;QACxB,CAAA;AACA,eAAOnB,OAAOoB,KAAK;UAAEC,MAAMZ,MAAMY;UAAMP;QAAK,CAAA;MAC9C,CAAA;AACA,aAAO,OAAOpB,UAAU4B,OAAO1B,eAAe2B,WAAW;QACvDX;QACAY,QAAQd,QAAQc;QAChBC,QAAQ;QACRC,cAAchB,QAAQgB;MACxB,CAAA;IACF,CAAA;EACJ,CAAA;AACF,CAAA,CAAA;",
+  "names": ["Effect", "Capability", "Operation", "Type", "SpaceOperation", "SpaceCapabilities", "ViewModel", "CreateKanbanSchema", "Kanban", "makeModule", "fnUntraced", "contributes", "CreateObjectEntry", "id", "getTypename", "inputSchema", "createObject", "props", "options", "gen", "object", "promise", "view", "makeFromDatabase", "db", "typename", "pivotFieldName", "initialPivotColumn", "make", "name", "invoke", "AddObject", "target", "hidden", "targetNodeId"]
+}

package/dist/lib/neutral/delete-card-4QF3TKXO.mjs

@@ -0,0 +1,24 @@
+import {
+  KanbanOperation_exports
+} from "./chunk-PNGVV67W.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/delete-card.ts
+import * as Effect from "effect/Effect";
+import { Operation } from "@dxos/compute";
+import { Obj } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-kanban/src/operations/delete-card.ts";
+var handler = KanbanOperation_exports.DeleteCard.pipe(Operation.withHandler(({ card }) => Effect.sync(() => {
+  const db = Obj.getDatabase(card);
+  invariant(db, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 9, S: void 0, A: ["db", ""] });
+  db.remove(card);
+  return {
+    card
+  };
+})));
+var delete_card_default = handler;
+export {
+  delete_card_default as default
+};
+//# sourceMappingURL=delete-card-4QF3TKXO.mjs.map

package/dist/lib/neutral/delete-card-4QF3TKXO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/delete-card.ts"],
+  "sourcesContent": ["// Copyright 2025 DXOS.org\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\nimport { Obj } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\n\nimport { KanbanOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof KanbanOperation.DeleteCard> = KanbanOperation.DeleteCard.pipe(\n  Operation.withHandler(({ card }) =>\n    Effect.sync(() => {\n      const db = Obj.getDatabase(card);\n      invariant(db);\n      db.remove(card);\n\n      return { card };\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;AAEA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,WAAW;AACpB,SAASC,iBAAiB;AAI1B,IAAA,eAA0EC;cAIpEC,wBAAUC,WAAAA,KAAAA,UAAAA,YAAAA,CAAAA,EAAAA,KAAAA,MAAAA,YAAAA,MAAAA;AACVA,QAAGC,KAAOC,IAAAA,YAAAA,IAAAA;AAEV,YAAO,IAAA,QAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,GAAA,GAAA,QAAA,GAAA,CAAA,MAAA,EAAA,EAAA,CAAA;YAAEA,IAAAA;AAAK,SAAA;IAChB;EAIJ;;;",
+  "names": ["Effect", "Operation", "Obj", "invariant", "KanbanOperation", "invariant", "db", "remove", "card"]
+}

package/dist/lib/neutral/delete-card-field-5M4ZHKLO.mjs

@@ -0,0 +1,39 @@
+import {
+  KanbanOperation_exports
+} from "./chunk-PNGVV67W.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/delete-card-field.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { Obj, Type } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from "@dxos/schema";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-kanban/src/operations/delete-card-field.ts";
+var handler = KanbanOperation_exports.DeleteCardField.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ view, fieldId }) {
+  const registry = yield* Capability.get(Capabilities.AtomRegistry);
+  const db = Obj.getDatabase(view);
+  invariant(db, "Database not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 12, S: this, A: ["db", "'Database not found'"] });
+  const types = yield* Effect.sync(() => db.graph.registry.list().filter(Type.isType));
+  const schema = types.find((t) => Type.getTypename(t) === getTypenameFromQuery(view.query.ast));
+  invariant(schema, "Schema not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 15, S: this, A: ["schema", "'Schema not found'"] });
+  invariant(Type.isType(schema), "expected stored Type.Type for card schema", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 16, S: this, A: ["Type.isType(schema)", "'expected stored Type.Type for card schema'"] });
+  const projection = new ProjectionModel({
+    registry,
+    view,
+    baseSchema: schema.jsonSchema,
+    change: createEchoChangeCallback(view, schema)
+  });
+  const result = projection.deleteFieldProjection(fieldId);
+  return {
+    field: result.deleted.field,
+    props: result.deleted.props,
+    index: result.index
+  };
+})));
+var delete_card_field_default = handler;
+export {
+  delete_card_field_default as default
+};
+//# sourceMappingURL=delete-card-field-5M4ZHKLO.mjs.map

package/dist/lib/neutral/delete-card-field-5M4ZHKLO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/delete-card-field.ts"],
+  "sourcesContent": ["// Copyright 2025 DXOS.org\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { Operation } from '@dxos/compute';\nimport { Obj, Type } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\nimport { ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';\n\nimport { KanbanOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof KanbanOperation.DeleteCardField> = KanbanOperation.DeleteCardField.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ view, fieldId }) {\n      const registry = yield* Capability.get(Capabilities.AtomRegistry);\n      const db = Obj.getDatabase(view);\n      invariant(db, 'Database not found');\n      const types = yield* Effect.sync(() => db.graph.registry.list().filter(Type.isType));\n      const schema = types.find((t) => Type.getTypename(t) === getTypenameFromQuery(view.query.ast));\n      invariant(schema, 'Schema not found');\n\n      invariant(Type.isType(schema), 'expected stored Type.Type for card schema');\n      const projection = new ProjectionModel({\n        registry,\n        view,\n        baseSchema: schema.jsonSchema,\n        change: createEchoChangeCallback(view, schema),\n      });\n\n      const result = projection.deleteFieldProjection(fieldId);\n\n      return {\n        field: result.deleted.field,\n        props: result.deleted.props,\n        index: result.index,\n      };\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;AAEA,YAAYA,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,iBAAiB;AAC1B,SAASC,KAAKC,YAAY;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,iBAAiBC,0BAA0BC,4BAA4B;AAIhF,IAAA,eAA+EC;IAIzE,UAAWC,wBAAgBC,gBAAAA,KAAAA,UAAAA,YAAAA,kBAAAA,WAAAA,EAAAA,MAAAA,QAAAA,GAAAA;AAC3BC,QAAAA,WAAc,OAAA,WAAA,IAAA,aAAA,YAAA;AACd,QAAMC,KAAAA,IAAQ,YAAOC,IAAOC;AAC5B,YAAMC,IAAAA,sBAA2BC,EAAKC,YAAW,YAAQC,GAAAA,cAAAA,GAAAA,IAAqBR,GAAAA,MAAKS,GAAMC,CAAAA,MAAG,sBAAA,EAAA,CAAA;AAC5FT,QAAAA,QAAUI,OAAQ,YAAA,MAAA,GAAA,MAAA,SAAA,KAAA,EAAA,OAAA,KAAA,MAAA,CAAA;AAElBJ,QAAAA,SAAeU,MAAM,KAACN,CAAAA,MAAS,KAAA,YAAA,CAAA,MAAA,qBAAA,KAAA,MAAA,GAAA,CAAA;AAC/B,YAAMO,QAAAA,oBAAiBC,EAAAA,YAAgB,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,MAAA,GAAA,CAAA,UAAA,oBAAA,EAAA,CAAA;YACrCC,KAAAA,OAAAA,MAAAA,GAAAA,6CAAAA,EAAAA,YAAAA,YAAAA,GAAAA,cAAAA,GAAAA,IAAAA,GAAAA,MAAAA,GAAAA,CAAAA,uBAAAA,6CAAAA,EAAAA,CAAAA;QACAd,aAAAA,IAAAA,gBAAAA;IACAe;IACAC;IACF,YAAA,OAAA;IAEA,QAAMC,yBAAoBC,MAAAA,MAAsBC;EAEhD,CAAA;QACEC,SAAOH,WAAeG,sBAAK,OAAA;SAC3BC;IACAC,OAAOL,OAAOK,QAAK;IACrB,OAAA,OAAA,QAAA;IACF,OAAA,OAAA;EAIJ;;;",
+  "names": ["Effect", "Capabilities", "Capability", "Operation", "Obj", "Type", "invariant", "ProjectionModel", "createEchoChangeCallback", "getTypenameFromQuery", "KanbanOperation", "Obj", "view", "invariant", "types", "Effect", "sync", "schema", "Type", "getTypename", "getTypenameFromQuery", "query", "ast", "isType", "projection", "ProjectionModel", "registry", "baseSchema", "change", "result", "deleteFieldProjection", "fieldId", "field", "props", "index"]
+}

package/dist/lib/neutral/hooks/index.mjs

@@ -0,0 +1,432 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/hooks/useEchoChangeCallback.ts
+import { useMemo } from "react";
+import { Obj } from "@dxos/echo";
+var createEchoChangeCallback = (kanban) => ({
+  kanban: (mutate) => Obj.update(kanban, (kanban2) => mutate(kanban2)),
+  setItemField: (item, field, value) => {
+    Obj.update(item, (item2) => {
+      item2[field] = value;
+    });
+  }
+});
+var useEchoChangeCallback = (kanban) => useMemo(() => kanban ? createEchoChangeCallback(kanban) : null, [
+  kanban
+]);
+
+// src/hooks/useItemsProjection.ts
+import { Atom } from "@effect-atom/atom-react";
+import { useMemo as useMemo2 } from "react";
+var useItemsProjection = (kanban) => {
+  return useMemo2(() => {
+    const pivotField = kanban.spec.pivotField;
+    const optionIds = Object.keys(kanban.arrangement?.columns ?? {});
+    const options = optionIds.map((id) => ({
+      id,
+      title: id,
+      color: "neutral"
+    }));
+    const fieldProjection = {
+      field: {
+        id: pivotField,
+        path: pivotField
+      },
+      props: {
+        property: pivotField,
+        options
+      }
+    };
+    const fields = Atom.make(() => [
+      fieldProjection.field
+    ]);
+    const stub = {
+      fields,
+      tryGetFieldProjection: (id) => id === pivotField ? fieldProjection : void 0,
+      getFieldProjections: () => [],
+      getHiddenProperties: () => [
+        pivotField
+      ]
+    };
+    return stub;
+  }, [
+    kanban.arrangement?.columns,
+    kanban.spec.pivotField
+  ]);
+};
+
+// src/hooks/useKanbanBoardModel.ts
+import { Atom as Atom2 } from "@effect-atom/atom-react";
+import { useMemo as useMemo3 } from "react";
+import { Obj as Obj2 } from "@dxos/echo";
+import { AtomObj } from "@dxos/echo-atom";
+
+// src/util/arrangement.ts
+import { UNCATEGORIZED_VALUE } from "#types";
+var getOrderFromArrangement = (arrangement) => {
+  const order = arrangement?.order;
+  if (order != null && Array.isArray(order) && 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]) => {
+      const rawIds = entry.ids;
+      const ids = Array.isArray(rawIds) ? [
+        ...rawIds
+      ] : [];
+      return [
+        key,
+        {
+          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.filter((columnValue) => effectiveByColumn[columnValue]?.hidden !== true).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 = useMemo3(() => AtomObj.makeProperty(kanban, "arrangement"), [
+    kanban
+  ]);
+  const viewSnapshotAtom = useMemo3(() => kanban?.spec?.kind === "view" && kanban.spec.view ? AtomObj.make(kanban.spec.view) : Atom2.make(() => void 0), [
+    kanban?.spec
+  ]);
+  const pivotFieldIdAtom = useMemo3(() => Atom2.make((get) => {
+    if (kanban?.spec.kind === "items") {
+      return kanban.spec.pivotField;
+    }
+    return get(viewSnapshotAtom)?.projection?.pivotFieldId;
+  }), [
+    kanban?.spec,
+    viewSnapshotAtom
+  ]);
+  const effectiveByColumnAtom = useMemo3(() => Atom2.make((get) => getOrderByColumnFromArrangement(get(arrangementAtom))), [
+    arrangementAtom
+  ]);
+  const columnsAtom = useMemo3(() => Atom2.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 = useMemo3(() => Atom2.family((columnValue) => Atom2.make((get) => {
+    const byColumn = get(effectiveByColumnAtom);
+    return {
+      columnValue,
+      ids: [
+        ...byColumn[columnValue]?.ids ?? []
+      ]
+    };
+  })), [
+    effectiveByColumnAtom
+  ]);
+  const itemsAtomFamily = useMemo3(() => Atom2.family((columnValue) => Atom2.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 useMemo3(() => ({
+    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 useMemo4 } from "react";
+import { arrayMove } from "@dxos/util";
+import { UNCATEGORIZED_VALUE as UNCATEGORIZED_VALUE2 } from "#types";
+function useKanbanColumnEventHandler({ id, model, projection, pivotFieldId, change }) {
+  return useMemo4(() => ({
+    id,
+    canDrop: ({ source }) => {
+      if (!projection) {
+        return false;
+      }
+      const data = source.data;
+      const columnValue = model.getColumnId(data);
+      return model.isColumn(source.data) && columnValue !== UNCATEGORIZED_VALUE2 && source.id !== UNCATEGORIZED_VALUE2;
+    },
+    onDrop: ({ source, target }) => {
+      if (!projection || pivotFieldId === void 0) {
+        return;
+      }
+      const sourceColumnData = source.data;
+      const sourceColumnId = model.getColumnId(sourceColumnData);
+      if (sourceColumnId === UNCATEGORIZED_VALUE2) {
+        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_VALUE2);
+      });
+    }
+  }), [
+    id,
+    model,
+    projection,
+    pivotFieldId,
+    change
+  ]);
+}
+
+// src/hooks/useKanbanItemEventHandler.ts
+import { useMemo as useMemo5 } from "react";
+import { UNCATEGORIZED_VALUE as UNCATEGORIZED_VALUE3 } from "#types";
+function findColumn(id, arrangement) {
+  return arrangement.find(({ columnValue, cards }) => columnValue === id || cards.some((card) => card.id === id));
+}
+function useKanbanItemEventHandler({ column, columnFieldPath, model, change }) {
+  return useMemo5(() => ({
+    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_VALUE3 ? 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
+  ]);
+}
+
+// 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 || kanban.spec.kind !== "view") {
+      return;
+    }
+    try {
+      const view = await kanban.spec.view.load();
+      if (controller.signal.aborted) {
+        return;
+      }
+      const jsonSchema = Type.getDatabase(schema) != null ? schema.jsonSchema : JsonSchema.toJsonSchema(schema);
+      const change = createEchoChangeCallback2(view, Type.getDatabase(schema) != null ? 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
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 41, S: void 0 });
+    }
+  }, [
+    schema,
+    kanban,
+    registry
+  ]);
+  return projection;
+};
+export {
+  createEchoChangeCallback,
+  useEchoChangeCallback,
+  useItemsProjection,
+  useKanbanBoardModel,
+  useKanbanColumnEventHandler,
+  useKanbanItemEventHandler,
+  useProjectionModel
+};
+//# sourceMappingURL=index.mjs.map