@multiplatform.one/backoffice 6.4.2 → 6.6.0

package/src/views/kanban-board-controls.tsx

@@ -0,0 +1,357 @@
+// Board-doc controls for the kanban view (desk parity):
+//   - KanbanBoardPicker — the "Select Kanban" switcher (saved Kanban Board
+//     docs for the doctype) with a "New board…" entry
+//   - CreateBoardDialog — name + grouping-field prompt for the REST insert
+//   - KanbanColumnMenu — per-column "…" menu (archive; rename is omitted on
+//     purpose: a column IS a Select option value, desk offers no rename)
+//   - KanbanBoardEnd — the board-end "Add column" affordance (anchored after
+//     the last column, where desk puts it) + restore menu for archived
+//     columns
+import {
+  Button,
+  ConfirmDialog,
+  DropdownMenu,
+  Text,
+  XStack,
+  YStack,
+  type DropdownMenuEntry,
+} from "@multiplatform.one/components";
+import { Data } from "@multiplatform.one/frappe-ui";
+import { useResolvedKnobs } from "@multiplatform.one/theme";
+import { CaretDownIcon, DotsThreeIcon, PlusIcon } from "@phosphor-icons/react";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { BACKOFFICE_I18N_NAMESPACE } from "../i18n";
+import type { KanbanBoardColumnConfig } from "./deskViewConfigs";
+import type { KanbanFieldOption } from "./kanban-field-picker";
+
+// ── Board picker ──────────────────────────────────────────────
+
+export interface KanbanBoardPickerProps {
+  /** Saved Kanban Board doc names for the doctype. */
+  names: readonly string[];
+  /** Name of the currently rendered board. */
+  active?: string;
+  onSelect: (name: string) => void;
+  /** Offered as a trailing "New board…" entry when set. */
+  onCreateNew?: () => void;
+}
+
+/**
+ * Desk "Select Kanban" switcher: a labeled DropdownMenu listing the saved
+ * boards (current one check-marked) plus a "New board…" entry. Controlled
+ * open state so a selection closes the menu (ViewHeader switcher pattern).
+ */
+export function KanbanBoardPicker({
+  names,
+  active,
+  onSelect,
+  onCreateNew,
+}: KanbanBoardPickerProps) {
+  const { t } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
+  const { knobProps } = useResolvedKnobs();
+  const [open, setOpen] = useState(false);
+
+  const items: DropdownMenuEntry[] = names.map((name) => ({
+    key: name,
+    label: name,
+    checked: name === active,
+    onCheckedChange: () => {
+      setOpen(false);
+      if (name !== active) onSelect(name);
+    },
+  }));
+  if (onCreateNew) {
+    if (items.length > 0) items.push({ separator: true });
+    items.push({
+      key: "__new-board__",
+      label: t("views.kanbanBoardNew", "New board…"),
+      icon: <PlusIcon size={14} />,
+      onSelect: () => {
+        setOpen(false);
+        onCreateNew();
+      },
+    });
+  }
+
+  return (
+    <XStack {...knobProps.gap} alignItems="center">
+      <Text color="$color10" fontSize="$2">
+        {t("views.kanbanBoard", "Board")}
+      </Text>
+      <DropdownMenu items={items} open={open} onOpenChange={setOpen} placement="bottom-start">
+        <Button
+          size="$3"
+          iconAfter={CaretDownIcon}
+          aria-label={t("views.kanbanBoardSwitch", "Switch board")}
+        >
+          {active ?? t("views.kanbanBoardNone", "No board")}
+        </Button>
+      </DropdownMenu>
+    </XStack>
+  );
+}
+
+// ── Create-board dialog ───────────────────────────────────────
+
+export interface CreateBoardDialogProps {
+  doctype: string;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  /** Select fields on offer as the board's grouping axis. */
+  fieldOptions: readonly KanbanFieldOption[];
+  /** Preselected grouping field (the view's current axis). */
+  defaultField?: string;
+  /** Persist the board; resolve on success (failures notify upstream). */
+  onCreate: (boardName: string, fieldName: string) => Promise<void>;
+}
+
+/**
+ * Desk "New Kanban Board" prompt: board name + the Select field its columns
+ * map onto (columns are seeded from that field's options).
+ */
+export function CreateBoardDialog({
+  doctype,
+  open,
+  onOpenChange,
+  fieldOptions,
+  defaultField,
+  onCreate,
+}: CreateBoardDialogProps) {
+  const { t } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
+  const [name, setName] = useState("");
+  const [fieldname, setFieldname] = useState<string | undefined>(undefined);
+  const [busy, setBusy] = useState(false);
+
+  const effectiveField =
+    (fieldname && fieldOptions.some((option) => option.fieldname === fieldname)
+      ? fieldname
+      : undefined) ??
+    (defaultField && fieldOptions.some((option) => option.fieldname === defaultField)
+      ? defaultField
+      : undefined) ??
+    fieldOptions[0]?.fieldname;
+  const fieldLabel =
+    fieldOptions.find((option) => option.fieldname === effectiveField)?.label ?? effectiveField;
+
+  const fieldItems: DropdownMenuEntry[] = fieldOptions.map((option) => ({
+    key: option.fieldname,
+    label: option.label,
+    checked: option.fieldname === effectiveField,
+    onCheckedChange: () => setFieldname(option.fieldname),
+  }));
+
+  const handleConfirm = async () => {
+    const boardName = name.trim();
+    if (!boardName || !effectiveField || busy) return;
+    setBusy(true);
+    try {
+      await onCreate(boardName, effectiveField);
+      setName("");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <ConfirmDialog
+      open={open}
+      onOpenChange={onOpenChange}
+      title={t("views.kanbanBoardCreateTitle", "New kanban board")}
+      confirmLabel={
+        busy
+          ? t("views.kanbanBoardCreateBusy", "Creating…")
+          : t("views.kanbanBoardCreateConfirm", "Create board")
+      }
+      confirmDisabled={!name.trim() || !effectiveField || busy}
+      confirmDisabledReason={
+        !name.trim()
+          ? t("views.kanbanBoardCreateMissingName", "Enter a board name")
+          : !effectiveField
+            ? t("views.kanbanBoardCreateMissingField", "No Select field to group by")
+            : undefined
+      }
+      onConfirm={() => {
+        void handleConfirm();
+      }}
+    >
+      <YStack gap="$3" minWidth={280}>
+        <Text color="$color11" fontSize="$3">
+          {t("views.kanbanBoardCreateBody", {
+            defaultValue: "Columns come from the chosen field's options ({{doctype}}).",
+            doctype,
+          })}
+        </Text>
+        <Data
+          label={t("views.kanbanBoardCreateName", "Board name")}
+          placeholder={t("views.kanbanBoardCreateNamePlaceholder", "e.g. Test Board")}
+          value={name}
+          onChange={(value) => setName(value)}
+          required
+        />
+        <XStack gap="$2" alignItems="center">
+          <Text color="$color10" fontSize="$2">
+            {t("views.kanbanBoardCreateField", "Group by")}
+          </Text>
+          <DropdownMenu items={fieldItems} placement="bottom-start">
+            <Button
+              size="$3"
+              iconAfter={CaretDownIcon}
+              aria-label={t("views.kanbanBoardCreateFieldSwitch", "Choose grouping field")}
+            >
+              {fieldLabel ??
+                t("views.kanbanBoardCreateMissingField", "No Select field to group by")}
+            </Button>
+          </DropdownMenu>
+        </XStack>
+      </YStack>
+    </ConfirmDialog>
+  );
+}
+
+// ── Per-column menu ───────────────────────────────────────────
+
+export interface KanbanColumnMenuProps {
+  /** Column value (= the Select option / board column_name). */
+  column: string;
+  onArchive: () => void;
+}
+
+/**
+ * Per-column "…" menu. Archive is the only entry on purpose: board columns
+ * support Active/Archived (Kanban Board Column.status); rename would orphan
+ * the cards (a column IS a field option value — desk offers no rename
+ * either).
+ */
+export function KanbanColumnMenu({ column, onArchive }: KanbanColumnMenuProps) {
+  const { t } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
+  const items: DropdownMenuEntry[] = [
+    {
+      key: "archive",
+      label: t("views.kanbanColumnArchive", "Archive column"),
+      onSelect: onArchive,
+    },
+  ];
+  return (
+    <DropdownMenu items={items} placement="bottom-end">
+      <Button
+        size="$2"
+        circular
+        chromeless
+        icon={<DotsThreeIcon size={14} />}
+        aria-label={t("views.kanbanColumnMenu", {
+          defaultValue: "Column options: {{column}}",
+          column,
+        })}
+      />
+    </DropdownMenu>
+  );
+}
+
+// ── Board-end: add column + archived restore ──────────────────
+
+export interface KanbanBoardEndProps {
+  /** Archived board columns, restorable from the menu here. */
+  archivedColumns: readonly KanbanBoardColumnConfig[];
+  /** All existing column names (any status) for the duplicate guard. */
+  existingColumns: readonly string[];
+  onAddColumn: (columnName: string) => Promise<void>;
+  onRestoreColumn: (columnName: string) => void;
+}
+
+/**
+ * Anchored board-end affordances (desk puts "Add Column" after the last
+ * column, never in detached chrome): an add-column prompt plus a restore
+ * menu when archived columns exist.
+ */
+export function KanbanBoardEnd({
+  archivedColumns,
+  existingColumns,
+  onAddColumn,
+  onRestoreColumn,
+}: KanbanBoardEndProps) {
+  const { t } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
+  const { knobProps } = useResolvedKnobs();
+  const [addOpen, setAddOpen] = useState(false);
+  const [columnName, setColumnName] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  const trimmed = columnName.trim();
+  const duplicate = trimmed.length > 0 && existingColumns.includes(trimmed);
+
+  const restoreItems: DropdownMenuEntry[] = archivedColumns
+    .filter((column) => column.column_name)
+    .map((column) => ({
+      key: String(column.column_name),
+      label: String(column.column_name),
+      onSelect: () => onRestoreColumn(String(column.column_name)),
+    }));
+
+  const handleConfirm = async () => {
+    if (!trimmed || duplicate || busy) return;
+    setBusy(true);
+    try {
+      await onAddColumn(trimmed);
+      setColumnName("");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <YStack {...knobProps.gap} minWidth={160} alignItems="stretch">
+      <Button size="$3" icon={PlusIcon} onPress={() => setAddOpen(true)}>
+        {t("views.kanbanAddColumn", "Add column")}
+      </Button>
+      {restoreItems.length > 0 && (
+        <DropdownMenu items={restoreItems} placement="bottom-end">
+          <Button
+            size="$3"
+            chromeless
+            iconAfter={CaretDownIcon}
+            aria-label={t("views.kanbanArchivedRestore", "Restore an archived column")}
+          >
+            {t("views.kanbanArchivedColumns", {
+              defaultValue: "Archived ({{count}})",
+              count: archivedColumns.length,
+            })}
+          </Button>
+        </DropdownMenu>
+      )}
+      <ConfirmDialog
+        open={addOpen}
+        onOpenChange={setAddOpen}
+        title={t("views.kanbanAddColumnTitle", "Add column")}
+        confirmLabel={
+          busy
+            ? t("views.kanbanAddColumnBusy", "Adding…")
+            : t("views.kanbanAddColumnConfirm", "Add column")
+        }
+        confirmDisabled={!trimmed || duplicate || busy}
+        confirmDisabledReason={
+          duplicate
+            ? t("views.kanbanAddColumnDuplicate", {
+                defaultValue: 'Column "{{name}}" already exists',
+                name: trimmed,
+              })
+            : !trimmed
+              ? t("views.kanbanAddColumnMissingName", "Enter a column name")
+              : undefined
+        }
+        onConfirm={() => {
+          void handleConfirm();
+        }}
+      >
+        <YStack gap="$3" minWidth={280}>
+          <Data
+            label={t("views.kanbanAddColumnName", "Column name")}
+            placeholder={t("views.kanbanAddColumnPlaceholder", "e.g. In Review")}
+            value={columnName}
+            onChange={(value) => setColumnName(value)}
+            required
+          />
+        </YStack>
+      </ConfirmDialog>
+    </YStack>
+  );
+}

package/src/views/kanban-field-picker.tsx

@@ -0,0 +1,92 @@
+// Grouping-axis helpers + picker control for the kanban view: which Select
+// fields a doctype can be boarded by, which one wins by default ("status"
+// first — desk convention), and a DropdownMenu control (ViewHeader switcher
+// pattern) to change the axis at runtime.
+import {
+  Button,
+  DropdownMenu,
+  Text,
+  XStack,
+  type DropdownMenuEntry,
+} from "@multiplatform.one/components";
+import type { DocFieldMeta, DoctypeMeta } from "../shared/useDoctypeMeta";
+import { useResolvedKnobs } from "@multiplatform.one/theme";
+import { CaretDownIcon } from "@phosphor-icons/react";
+import { useTranslation } from "react-i18next";
+import { BACKOFFICE_I18N_NAMESPACE } from "../i18n";
+
+/**
+ * Every visible Select field with options — the fields a kanban board can
+ * group by. Order follows the doctype's field order, so the first candidate
+ * is the desk-style fallback axis.
+ */
+export function kanbanFieldCandidates(meta: DoctypeMeta): DocFieldMeta[] {
+  return meta.fields.filter(
+    (field) =>
+      field.fieldtype === "Select" && !field.hidden && (field.options ?? "").trim().length > 0,
+  );
+}
+
+/**
+ * Default grouping axis when no Kanban Board doc governs: a Select field
+ * literally named "status" wins (desk convention), else the first Select
+ * field with options.
+ */
+export function preferredKanbanField(
+  candidates: readonly DocFieldMeta[],
+): DocFieldMeta | undefined {
+  return candidates.find((field) => field.fieldname === "status") ?? candidates[0];
+}
+
+/** One switchable grouping axis (a Select fieldname + its display label). */
+export interface KanbanFieldOption {
+  fieldname: string;
+  label: string;
+}
+
+export interface KanbanFieldPickerProps {
+  /** Axes on offer (board field first, then Select candidates), deduped. */
+  options: readonly KanbanFieldOption[];
+  /** Fieldname of the currently active grouping axis. */
+  active: string;
+  onSelect: (fieldname: string) => void;
+}
+
+/**
+ * Compact "Board field" switcher: a labeled DropdownMenu button listing the
+ * available grouping axes, with the active one disabled (same pattern as the
+ * ViewHeader view switcher). Menu-based on purpose — works with the same
+ * press/keyboard affordances on web, native, and GTK.
+ */
+export function KanbanFieldPicker({ options, active, onSelect }: KanbanFieldPickerProps) {
+  const { t } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
+  const { knobProps } = useResolvedKnobs();
+  const items: DropdownMenuEntry[] = options.map((option) => ({
+    key: option.fieldname,
+    label: option.label,
+    disabled: option.fieldname === active,
+    disabledReason:
+      option.fieldname === active
+        ? t("views.kanbanBoardFieldCurrent", "Current board field")
+        : undefined,
+    onSelect: () => onSelect(option.fieldname),
+  }));
+  const activeLabel = options.find((option) => option.fieldname === active)?.label ?? active;
+
+  return (
+    <XStack {...knobProps.gap} alignItems="center">
+      <Text color="$color10" fontSize="$2">
+        {t("views.kanbanBoardField", "Board field")}
+      </Text>
+      <DropdownMenu items={items} placement="bottom-start">
+        <Button
+          size="$3"
+          iconAfter={CaretDownIcon}
+          aria-label={t("views.kanbanBoardFieldSwitch", "Switch board field")}
+        >
+          {activeLabel}
+        </Button>
+      </DropdownMenu>
+    </XStack>
+  );
+}

package/src/views/kanbanBoardOps.spec.ts

@@ -0,0 +1,124 @@
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { describe, expect, it } from "vitest";
+import type { ViewConnection } from "./connection";
+import type { KanbanBoardDoc } from "./deskViewConfigs";
+import {
+  addKanbanColumn,
+  createKanbanBoard,
+  parseBoardFilters,
+  setKanbanColumnStatus,
+} from "./kanbanBoardOps";
+
+describe("parseBoardFilters", () => {
+  it("returns no filters for empty or missing input", () => {
+    expect(parseBoardFilters(undefined)).toEqual([]);
+    expect(parseBoardFilters("")).toEqual([]);
+  });
+
+  it("degrades malformed JSON and non-array shapes to no filters", () => {
+    expect(parseBoardFilters("not json")).toEqual([]);
+    expect(parseBoardFilters('{"a":1}')).toEqual([]);
+    expect(parseBoardFilters('["loose", 1]')).toEqual([]);
+  });
+
+  it("strips the doctype prefix from 4-tuple desk filters", () => {
+    expect(parseBoardFilters('[["ToDo","priority","=","Medium"]]')).toEqual([
+      ["priority", "=", "Medium"],
+    ]);
+  });
+
+  it("passes bare 3-tuple filters through", () => {
+    expect(parseBoardFilters('[["status","!=","Cancelled"]]')).toEqual([
+      ["status", "!=", "Cancelled"],
+    ]);
+  });
+
+  it("handles mixed tuple shapes and skips junk entries", () => {
+    expect(
+      parseBoardFilters(
+        '[["ToDo","priority","=","High"],["status","=","Open"],"junk",[["nested"]],[]]',
+      ),
+    ).toEqual([
+      ["priority", "=", "High"],
+      ["status", "=", "Open"],
+    ]);
+  });
+});
+
+function fixtureConnection(seed: Record<string, Array<Record<string, unknown>>>): {
+  connection: ViewConnection;
+  fixtures: InMemoryFixtureProvider;
+} {
+  const fixtures = new InMemoryFixtureProvider(seed as never);
+  return { connection: { baseURL: "https://fixtures.test", fixtures }, fixtures };
+}
+
+const seedBoard = {
+  name: "QA Board",
+  doctype: "Kanban Board",
+  kanban_board_name: "QA Board",
+  reference_doctype: "ToDo",
+  field_name: "status",
+  columns: [
+    { column_name: "Open", status: "Active" },
+    { column_name: "Closed", status: "Active" },
+  ],
+};
+
+describe("kanban board ops (fixture mode)", () => {
+  it("creates a board with columns seeded from the field options", async () => {
+    const { connection, fixtures } = fixtureConnection({ "Kanban Board": [] });
+    const name = await createKanbanBoard(connection, {
+      doctype: "ToDo",
+      boardName: "Sprint Board",
+      fieldName: "status",
+      columns: ["Open", "Closed", "Cancelled"],
+    });
+    expect(name).toBe("Sprint Board");
+    const doc = (await fixtures.getDoc("Kanban Board", "Sprint Board")) as
+      | (KanbanBoardDoc & { doctype: string })
+      | null;
+    expect(doc?.reference_doctype).toBe("ToDo");
+    expect(doc?.field_name).toBe("status");
+    expect(doc?.columns?.map((column) => column.column_name)).toEqual([
+      "Open",
+      "Closed",
+      "Cancelled",
+    ]);
+    expect(doc?.columns?.every((column) => column.status === "Active")).toBe(true);
+  });
+
+  it("appends a column to the board child table", async () => {
+    const { connection, fixtures } = fixtureConnection({ "Kanban Board": [seedBoard] });
+    await addKanbanColumn(connection, seedBoard as KanbanBoardDoc, "In Review");
+    const doc = (await fixtures.getDoc("Kanban Board", "QA Board")) as
+      | (KanbanBoardDoc & { doctype: string })
+      | null;
+    expect(doc?.columns?.map((column) => column.column_name)).toEqual([
+      "Open",
+      "Closed",
+      "In Review",
+    ]);
+  });
+
+  it("archives and restores a column by name", async () => {
+    const { connection, fixtures } = fixtureConnection({ "Kanban Board": [seedBoard] });
+    await setKanbanColumnStatus(connection, seedBoard as KanbanBoardDoc, "Closed", "Archived");
+    let doc = (await fixtures.getDoc("Kanban Board", "QA Board")) as
+      | (KanbanBoardDoc & { doctype: string })
+      | null;
+    expect(doc?.columns?.find((column) => column.column_name === "Closed")?.status).toBe(
+      "Archived",
+    );
+    await setKanbanColumnStatus(
+      connection,
+      { ...(seedBoard as KanbanBoardDoc), columns: doc?.columns },
+      "Closed",
+      "Active",
+    );
+    doc = (await fixtures.getDoc("Kanban Board", "QA Board")) as
+      | (KanbanBoardDoc & { doctype: string })
+      | null;
+    expect(doc?.columns?.find((column) => column.column_name === "Closed")?.status).toBe("Active");
+  });
+});

package/src/views/kanbanBoardOps.ts

@@ -0,0 +1,124 @@
+// Kanban Board doc mutations (desk parity), riding the same ViewConnection
+// as the reads in deskViewConfigs:
+//   - new boards: REST insert (POST /api/resource/Kanban Board) with columns
+//     seeded from the grouping field's Select options — the server seeds each
+//     column's card order in before_insert
+//   - column ops: the desk whitelisted RPCs (kanban_board.add_column /
+//     archive_restore_column), which validate duplicates and keep child-row
+//     identity + card order intact server-side
+// Fixture mode (stories/tests) mutates the fixture store instead, so the
+// view's refetch sees the change.
+import type { FrappeDocData } from "@multiplatform.one/frappe";
+import type { ViewConnection } from "./connection";
+import { createViewHttp, type KanbanBoardDoc } from "./deskViewConfigs";
+
+const KANBAN_RPC_BASE = "/api/method/frappe.desk.doctype.kanban_board.kanban_board";
+
+export interface CreateKanbanBoardInput {
+  /** Reference doctype the board is for (e.g. "ToDo"). */
+  doctype: string;
+  boardName: string;
+  /** The Select field the board's columns map onto. */
+  fieldName: string;
+  /** Column values, seeded from the field's Select options. */
+  columns: readonly string[];
+}
+
+/** Insert a Kanban Board doc; resolves to the created board's name. */
+export async function createKanbanBoard(
+  connection: ViewConnection,
+  input: CreateKanbanBoardInput,
+): Promise<string> {
+  const body = {
+    kanban_board_name: input.boardName,
+    reference_doctype: input.doctype,
+    field_name: input.fieldName,
+    columns: input.columns.map((column) => ({ column_name: column, status: "Active" })),
+  };
+  if (connection.fixtures) {
+    const created = await connection.fixtures.createDoc("Kanban Board", {
+      name: input.boardName,
+      doctype: "Kanban Board",
+      ...body,
+    });
+    return String(created.name ?? input.boardName);
+  }
+  const http = createViewHttp(connection);
+  const response = await http.post<{ data?: { name?: string } }>(
+    "/api/resource/Kanban%20Board",
+    body,
+  );
+  return response.payload?.data?.name ?? input.boardName;
+}
+
+/** Append a column to the board's child table (desk add_column RPC). */
+export async function addKanbanColumn(
+  connection: ViewConnection,
+  board: KanbanBoardDoc,
+  columnName: string,
+): Promise<void> {
+  if (connection.fixtures) {
+    // Fixture docs are plain JSON — the child rows intentionally lack the
+    // server-managed ChildTableRow bookkeeping fields.
+    await connection.fixtures.updateDoc("Kanban Board", board.name, {
+      columns: [...(board.columns ?? []), { column_name: columnName, status: "Active" }],
+    } as unknown as Partial<FrappeDocData>);
+    return;
+  }
+  const http = createViewHttp(connection);
+  await http.post(`${KANBAN_RPC_BASE}.add_column`, {
+    board_name: board.name,
+    column_title: columnName,
+  });
+}
+
+/** Archive or restore a board column (desk archive_restore_column RPC). */
+export async function setKanbanColumnStatus(
+  connection: ViewConnection,
+  board: KanbanBoardDoc,
+  columnName: string,
+  status: "Active" | "Archived",
+): Promise<void> {
+  if (connection.fixtures) {
+    await connection.fixtures.updateDoc("Kanban Board", board.name, {
+      columns: (board.columns ?? []).map((column) =>
+        column.column_name === columnName ? { ...column, status } : column,
+      ),
+    } as unknown as Partial<FrappeDocData>);
+    return;
+  }
+  const http = createViewHttp(connection);
+  await http.post(`${KANBAN_RPC_BASE}.archive_restore_column`, {
+    board_name: board.name,
+    column_title: columnName,
+    status,
+  });
+}
+
+/**
+ * Parse a Kanban Board `filters` JSON string into `[fieldname, operator,
+ * value]` tuples for the card query. Desk stores list-filter tuples either
+ * doctype-qualified (`[doctype, fieldname, operator, value]` — the shape
+ * quick_kanban_board writes) or bare (`[fieldname, operator, value]`).
+ * Malformed input degrades to no filters.
+ */
+export function parseBoardFilters(raw: string | undefined): Array<[string, string, unknown]> {
+  if (!raw) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const filters: Array<[string, string, unknown]> = [];
+  for (const entry of parsed) {
+    if (!Array.isArray(entry)) continue;
+    if (entry.length >= 4) {
+      filters.push([String(entry[1]), String(entry[2]), entry[3]]);
+    } else if (entry.length === 3) {
+      filters.push([String(entry[0]), String(entry[1]), entry[2]]);
+    }
+  }
+  return filters;
+}