@anchrd/intel-ui 0.38.0 → 0.40.0

package/src/board/board-task/board-task.ts

@@ -0,0 +1,105 @@
+import type { BoardTask } from "@anchrd/intel-contract/board";
+import type { ColumnWithCards } from "@/board/board-data/board-data.types.ts";
+
+/** What one entry of the task's link list is. The icon is drawn from this, nothing else. */
+/**
+ * ⚠️ **No `reference` kind yet, on purpose.** A plain reference is a link in the node graph and
+ * needs `node_link_list` — a second read this screen does not make. Carrying the kind here with no
+ * caller would be a path that looks built and is not; it is `#687` instead.
+ */
+export type LinkKind = "subtask" | "blocker" | "blocked";
+
+export interface TaskLink {
+  kind: LinkKind;
+  /** The linked node's id — its address, and the key of the row. */
+  id: string;
+  /** ⚠️ `null` when this answer holds no name for it. The VIEW decides what to say then; putting
+   * the id here would put it on screen. */
+  title: string | null;
+  /** The column the linked task sits in, so its state is readable without opening it. */
+  columnTitle: string | null;
+  /** Set on a subtask only: whether it sits in a column the board calls terminal. */
+  done: boolean;
+}
+
+/**
+ * ⚠️ **The order is a DECISION, not an accident.** Subtasks, blockers and references stand mixed in
+ * one list, and a list whose order nobody can name reorders itself on every load. The key is, in
+ * this order:
+ *
+ * 1. **by kind** — subtasks, then what this task waits for, then what waits for it. Subtasks first
+ *    because they carry the progress; what waits on this one last, because it says nothing about
+ *    whether this task itself can move.
+ * 2. **by the board's own position** within a kind, so the list reads in the same order as the
+ *    column it came from.
+ * 3. **by title**, only to break a tie — two cards may share a position after a filtered read.
+ */
+const kindOrder: Record<LinkKind, number> = {
+  subtask: 0,
+  blocker: 1,
+  blocked: 2,
+};
+
+export function linksOf(task: BoardTask, columns: ColumnWithCards[]): TaskLink[] {
+  const cards = columns.flatMap((entry) =>
+    entry.cards.map((card) => ({ card, column: entry.column })),
+  );
+  const at = (id: string | null) =>
+    id === null ? undefined : cards.find((entry) => entry.card.id === id);
+  const position = (id: string) => at(id)?.card.position ?? Number.POSITIVE_INFINITY;
+
+  const links: TaskLink[] = [];
+
+  for (const { card, column } of cards) {
+    if (card.parentTaskId === task.id) {
+      links.push({
+        kind: "subtask",
+        id: card.id,
+        title: card.title,
+        columnTitle: column.title,
+        done: column.terminal,
+      });
+    }
+    // ⚠️ The other direction too. `dependsOn` is stored on the waiting card, so a task only learns
+    // what waits for IT by looking at every card — and that is exactly what somebody opening a
+    // blocker wants to know before they move it.
+    if (card.dependsOn === task.id && card.id !== task.id) {
+      links.push({
+        kind: "blocked",
+        id: card.id,
+        title: card.title,
+        columnTitle: column.title,
+        done: false,
+      });
+    }
+  }
+
+  if (task.dependsOn !== null) {
+    const blocking = at(task.dependsOn);
+    links.push({
+      kind: "blocker",
+      id: task.dependsOn,
+      // ⚠️ **`null`, never the id.** A blocker may be any node, not only a card of this board, so
+      // this answer often has no title for it — and an id put on screen in place of a name is the
+      // rule in `user-name.ts` (#258) broken with a node id instead of a principal id. The view
+      // says "something outside this board"; the id says nothing at all.
+      title: blocking?.card.title ?? null,
+      columnTitle: blocking?.column.title ?? null,
+      done: false,
+    });
+  }
+
+  return links.sort(
+    (a, b) =>
+      kindOrder[a.kind] - kindOrder[b.kind] ||
+      position(a.id) - position(b.id) ||
+      (a.title ?? "").localeCompare(b.title ?? ""),
+  );
+}
+
+/** How far the subtasks have got — `null` when there are none, so the view draws nothing. */
+export function progressOf(links: TaskLink[]): { done: number; total: number } | null {
+  const subtasks = links.filter((link) => link.kind === "subtask");
+  if (subtasks.length === 0) return null;
+  return { done: subtasks.filter((link) => link.done).length, total: subtasks.length };
+}

package/src/board/board-task/board-task.tsx

@@ -0,0 +1,364 @@
+import type { BoardTask } from "@anchrd/intel-contract/board";
+import { ARCHIVE_COLUMN_ID } from "@anchrd/intel-contract/board";
+import { ChevronLeft, Lock, Plus, Square, SquareCheck } from "lucide-react";
+import { useState } from "react";
+import { useAssigneeLabel } from "@/board/board-assignee/board-assignee.ts";
+import type { BoardHandle } from "@/board/board-data/board-data.types.ts";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu.tsx";
+import { useI18n } from "@/i18n/i18n-context.tsx";
+import { initials } from "@/user-name/user-name.ts";
+import { type LinkKind, linksOf, progressOf, type TaskLink } from "./board-task.ts";
+
+const linkIcons: Record<LinkKind, typeof Lock> = {
+  subtask: Square,
+  blocker: Lock,
+  blocked: Lock,
+};
+
+/**
+ * Who the task is for, as the circle the access summary uses.
+ *
+ * ⚠️ **One person, not a group.** Jack's decision 2026-08-20: the STYLE is borrowed, the field stays
+ * `assigneeId`. A row of circles here would imply a second data model that does not exist.
+ */
+function Assignee({ id }: { id: string | null }) {
+  const i18n = useI18n();
+  const label = useAssigneeLabel(id);
+  if (id === null) {
+    return <span className="text-xs text-muted-foreground">{label}</span>;
+  }
+  return (
+    <span
+      // ⚠️ `role="img"` and not a bare span: two initials are a picture of a name, and a plain
+      // `span` carries no `aria-label` at all — the attribute is dropped, and the circle is then
+      // read out as the two letters it happens to contain.
+      role="img"
+      aria-label={label}
+      title={label}
+      className="flex size-7 items-center justify-center rounded-full bg-accent text-xs font-medium text-accent-foreground ring-2 ring-background"
+    >
+      {initials(label)}
+    </span>
+  );
+}
+
+/** One entry of the link list. The icon carries the kind; nothing writes the word out. */
+function LinkRow({ link, onOpen }: { link: TaskLink; onOpen(id: string): void }) {
+  const i18n = useI18n();
+  const Icon = link.kind === "subtask" && link.done ? SquareCheck : linkIcons[link.kind];
+  return (
+    <li className="flex items-center gap-2 border-b py-2 last:border-0">
+      <Icon
+        aria-hidden="true"
+        className={`size-4 shrink-0 ${link.kind === "blocker" ? "text-destructive" : "text-muted-foreground"}`}
+      />
+      <button
+        type="button"
+        onClick={() => onOpen(link.id)}
+        className="flex-1 truncate text-left text-sm outline-none hover:underline focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        {/* ⚠️ A name or a sentence, never the id. This answer holds no title for a node outside the
+            board, and a ulid on screen is a label nobody can read (`user-name.ts`, #258). */}
+        {link.title ?? i18n.t("board.link.outside")}
+      </button>
+      {/* ⚠️ The column of the LINKED task, so its state is readable without opening it — the whole
+          reason the list carries a right-hand column at all. */}
+      {/* ⚠️ Empty rather than a word, and no template over the kind. Only a BLOCKER can be without
+          a column — it may be any node, not a card of this board — and the title beside it already
+          says "outside this board". A `board.link.${kind}` lookup could reach exactly one of the
+          three keys, and kept the other two alive in all three catalogs for nobody. */}
+      <span className="shrink-0 text-xs text-muted-foreground">{link.columnTitle ?? ""}</span>
+    </li>
+  );
+}
+
+export function BoardTaskDocument({
+  task,
+  board,
+  onOpen,
+  onClose,
+  body,
+}: {
+  task: BoardTask;
+  board: BoardHandle;
+  onOpen(taskId: string): void;
+  onClose(): void;
+  /** The markdown surface, handed in so this component stays free of the editor's own loading. */
+  body: React.ReactNode;
+}) {
+  const i18n = useI18n();
+  const [label, setLabel] = useState("");
+  const [adding, setAdding] = useState(false);
+
+  const links = linksOf(task, board.columns);
+  const progress = progressOf(links);
+  const columns = board.columns.filter((entry) => entry.unknown !== true).map((e) => e.column);
+  const column = columns.find((entry) => entry.id === task.status);
+
+  /**
+   * ⚠️ **Refused while a write is in flight, like every other surface of this board.** Labels make
+   * it worst: the whole list is REPLACED, so two quick clicks each send the list minus their own
+   * entry, the second answer wins, and one of the two removals is silently undone — both calls
+   * succeeded, so nothing anywhere reports a problem (#651).
+   */
+  const write = (input: Partial<Omit<Parameters<BoardHandle["updateTask"]>[0], "taskId">>) => {
+    if (board.isWriting) return;
+    void board.updateTask({
+      taskId: task.id,
+      ...input,
+      idempotencyKey: crypto.randomUUID(),
+    });
+  };
+
+  // ⚠️ A single date has to say WHICH one it is. Drawn bare, a start date and a due date look
+  // identical — and reading a start date as a deadline is the expensive direction of that mistake.
+  const dates =
+    task.startDate !== null && task.dueDate !== null
+      ? `${task.startDate.slice(0, 10)} – ${task.dueDate.slice(0, 10)}`
+      : task.startDate !== null
+        ? i18n.t("board.fromDate", { date: task.startDate.slice(0, 10) })
+        : task.dueDate !== null
+          ? i18n.t("board.untilDate", { date: task.dueDate.slice(0, 10) })
+          : null;
+
+  return (
+    <div
+      className="flex min-h-0 flex-1 flex-col gap-4 overflow-auto p-6"
+      aria-busy={board.isWriting}
+    >
+      <button
+        type="button"
+        onClick={onClose}
+        className="flex w-fit items-center gap-1 rounded-md text-sm text-muted-foreground outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        <ChevronLeft aria-hidden="true" className="size-4" />
+        {board.title}
+      </button>
+
+      <h1 className="text-2xl font-semibold tracking-tight">{task.title}</h1>
+
+      {/* ⚠️ ONE line of chips, and no field labels. "Status:" in front of a chip that says "Backlog"
+          says nothing the chip does not — and it turns a quiet head into a form. */}
+      <div className="flex flex-wrap items-center gap-2">
+        <DropdownMenu>
+          <DropdownMenuTrigger
+            aria-label={i18n.t("board.moveTo")}
+            className="rounded-full border px-3 py-1 text-xs outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            {column?.title ?? task.status}
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="start">
+            <DropdownMenuRadioGroup
+              value={task.status}
+              // ⚠️ Where a task SITS is a move, not a field edit: the server computes a position and
+              // checks the cycles for it. Everything else on this screen is a plain change.
+              onValueChange={(next) => write({ status: next })}
+            >
+              {columns.map((entry) => (
+                <DropdownMenuRadioItem key={entry.id} value={entry.id}>
+                  {entry.title}
+                </DropdownMenuRadioItem>
+              ))}
+              <DropdownMenuRadioItem value={ARCHIVE_COLUMN_ID}>
+                {i18n.t("board.column.archive")}
+              </DropdownMenuRadioItem>
+            </DropdownMenuRadioGroup>
+          </DropdownMenuContent>
+        </DropdownMenu>
+
+        <Assignee id={task.assigneeId} />
+
+        {dates === null ? null : (
+          <span className="rounded-full border px-3 py-1 text-xs tabular-nums">{dates}</span>
+        )}
+
+        {task.labels.map((entry) => (
+          <button
+            key={entry}
+            type="button"
+            aria-label={i18n.t("board.removeLabel", { label: entry })}
+            onClick={() => write({ labels: task.labels.filter((keep) => keep !== entry) })}
+            className="rounded-full bg-muted px-3 py-1 text-xs outline-none hover:bg-muted/70 focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            {entry}
+          </button>
+        ))}
+
+        {adding ? (
+          <input
+            // biome-ignore lint/a11y/noAutofocus: it opens on a deliberate click, never on load
+            autoFocus
+            value={label}
+            aria-label={i18n.t("board.addLabel")}
+            onChange={(event) => setLabel(event.target.value)}
+            onKeyDown={(event) => {
+              if (event.key === "Escape") {
+                setAdding(false);
+                setLabel("");
+              }
+              if (event.key !== "Enter") return;
+              event.preventDefault();
+              const next = label.trim();
+              // ⚠️ Tags are REPLACED, not merged, so the whole list travels — and a duplicate would
+              // be written as one more entry rather than refused.
+              if (next.length > 0 && !task.labels.includes(next)) {
+                write({ labels: [...task.labels, next] });
+              }
+              setAdding(false);
+              setLabel("");
+            }}
+            className="w-28 rounded-full border bg-background px-3 py-1 text-xs outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          />
+        ) : (
+          <button
+            type="button"
+            aria-label={i18n.t("board.addLabel")}
+            onClick={() => setAdding(true)}
+            className="rounded-full border px-2 py-1 text-xs outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            <Plus aria-hidden="true" className="size-3" />
+          </button>
+        )}
+      </div>
+
+      {/* ⚠️ ONE list, not three blocks. The icon carries the kind — box, lock, chain — and the order
+          is the decision documented on `linksOf`. */}
+      <section aria-label={i18n.t("board.links")} className="flex flex-col gap-1">
+        <h2 className="flex items-center gap-2 text-sm font-medium">
+          {i18n.t("board.links")}
+          {progress === null ? null : (
+            <span className="text-xs text-muted-foreground tabular-nums">
+              {i18n.t("board.progress", { done: progress.done, total: progress.total })}
+            </span>
+          )}
+        </h2>
+        {links.length === 0 ? null : (
+          <ul className="flex flex-col">
+            {links.map((link) => (
+              <LinkRow key={`${link.kind}:${link.id}`} link={link} onOpen={onOpen} />
+            ))}
+          </ul>
+        )}
+        <LinkAdder task={task} board={board} />
+      </section>
+
+      {/* The markdown text is the largest element of the page — everything above is the quiet part.
+          ⚠️ The slot is not decoration: a test that asks whether the BODY drew something has to be
+          able to say which part of the card it means. Unscoped, the same loading line elsewhere on
+          the card answers for it, and the assurance goes hollow without anybody touching it. */}
+      <div data-slot="task-body" className="min-h-0 flex-1">
+        {body}
+      </div>
+    </div>
+  );
+}
+
+/**
+ * ⚠️ **ONE `+ Verlinkung`, and the kind is chosen afterwards** — not two buttons labelled "subtask"
+ * and "waits for". That is `#371`: the reader decides WHAT they are linking once they know which
+ * card they mean, not before.
+ */
+function LinkAdder({ task, board }: { task: BoardTask; board: BoardHandle }) {
+  const i18n = useI18n();
+  const [kind, setKind] = useState<"subtask" | "blocker" | null>(null);
+  const [title, setTitle] = useState("");
+
+  const candidates = board.columns
+    .flatMap((entry) => entry.cards)
+    .filter((card) => card.id !== task.id && card.parentTaskId !== task.id);
+
+  const close = () => {
+    setKind(null);
+    setTitle("");
+  };
+
+  return (
+    <div className="flex items-center gap-2 pt-1">
+      <DropdownMenu>
+        <DropdownMenuTrigger className="flex items-center gap-1 rounded-md px-2 py-1 text-xs text-muted-foreground outline-none hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring">
+          <Plus aria-hidden="true" className="size-3" />
+          {i18n.t("board.addLink")}
+        </DropdownMenuTrigger>
+        <DropdownMenuContent align="start">
+          <DropdownMenuItem onSelect={() => setKind("subtask")}>
+            {i18n.t("board.link.subtask")}
+          </DropdownMenuItem>
+          <DropdownMenuItem onSelect={() => setKind("blocker")}>
+            {i18n.t("board.link.blocker")}
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>
+
+      {/* ⚠️ **The two kinds are two different writes, and that is why the kind is asked FIRST.** A
+          subtask is CREATED — where a task sits is the node tree, and moving an existing card under
+          another needs `node_update` with the version it was last read at, which this answer does
+          not carry. A blocker is a field on this card and only needs the card that is meant. */}
+      {kind === "subtask" ? (
+        <input
+          // biome-ignore lint/a11y/noAutofocus: it opens on a deliberate click, never on load
+          autoFocus
+          value={title}
+          aria-label={i18n.t("board.link.subtask")}
+          onChange={(event) => setTitle(event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key === "Escape") close();
+            if (event.key !== "Enter") return;
+            event.preventDefault();
+            const next = title.trim();
+            if (next.length === 0 || board.isWriting) return;
+            void board
+              .createTask({
+                title: next,
+                // A subtask starts in the same column as the task it belongs to — the alternative
+                // is the first column, which claims work was reset that never started.
+                status: task.status,
+                parentTaskId: task.id,
+                assigneeId: null,
+                labels: [],
+                startDate: null,
+                dueDate: null,
+                dependsOn: null,
+                idempotencyKey: crypto.randomUUID(),
+              })
+              .then(close);
+          }}
+          className="w-48 rounded-md border bg-background px-2 py-1 text-xs outline-none focus-visible:ring-2 focus-visible:ring-ring"
+        />
+      ) : kind === "blocker" ? (
+        <DropdownMenu open onOpenChange={(next) => !next && close()}>
+          <DropdownMenuTrigger
+            aria-label={i18n.t("board.link.blocker")}
+            className="rounded-md border px-2 py-1 text-xs outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          >
+            {i18n.t("board.link.blocker")}
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="start">
+            {candidates.map((card) => (
+              <DropdownMenuItem
+                key={card.id}
+                onSelect={() => {
+                  close();
+                  if (board.isWriting) return;
+                  void board.updateTask({
+                    taskId: task.id,
+                    dependsOn: card.id,
+                    idempotencyKey: crypto.randomUUID(),
+                  });
+                }}
+              >
+                {card.title}
+              </DropdownMenuItem>
+            ))}
+          </DropdownMenuContent>
+        </DropdownMenu>
+      ) : null}
+    </div>
+  );
+}

package/src/frontmatter/frontmatter.tsx

@@ -110,14 +110,23 @@ export function FrontmatterHead({ raw }: { raw: string }) {
       // The editor owns the text around this; the head itself is not typed into.
       contentEditable={false}
       data-frontmatter={open ? "open" : "closed"}
-      className="my-2 w-full rounded-md border border-border bg-muted/40"
+      // ⚠️ No border and no vertical margin (#667). The head sits directly under the document's
+      // title, and a framed box there asks for more attention than metadata deserve. The tinted
+      // surface stays: without any ground at all the keys read as the first paragraph of the text,
+      // which is the state #657 came from.
+      //
+      // ⚠️ The margin is what the drag handle and the `+` line up against — BlockNote centres them
+      // on the block's own box, not on what is drawn inside it. `my-2` pushed the strip 12px below
+      // them; measured in a real editor, removing it leaves 2px, which is the difference between
+      // this row and a line of text.
+      className="w-full rounded-md bg-muted/40"
     >
       <button
         type="button"
         aria-expanded={open}
         aria-label={labels.expand}
         onClick={() => setOpen(!open)}
-        className="flex w-full items-center gap-2 rounded-md px-3 py-1.5 text-left text-sm text-muted-foreground outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring"
+        className="flex w-full items-center gap-2 rounded-md px-3 py-1 text-left text-sm text-muted-foreground outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring"
       >
         <ChevronRight
           aria-hidden="true"

package/src/i18n/de.json

@@ -33,8 +33,15 @@
   "auth.signOutFailed": "Das Abmelden ist fehlgeschlagen. Prüfe deine Verbindung und versuche es erneut.",
   "board.addCard": "+ Aufgabe",
   "board.addCardIn": "Eine Aufgabe zu {column} hinzufügen",
-  "board.cardLabel": "{title}, in {column}. Mit Alt und den Pfeiltasten verschieben.",
+  "board.addLabel": "Label hinzufügen",
+  "board.addLink": "Verlinkung",
+  "board.cardLabel": "{title} öffnen, in {column}. Alt und eine Pfeiltaste verschiebt sie.",
+  "board.column.archive": "Archiv",
   "board.column.assignee": "Zuständig",
+  "board.column.default.backlog": "Backlog",
+  "board.column.default.doing": "Läuft",
+  "board.column.default.done": "Fertig",
+  "board.column.default.todo": "Offen",
   "board.column.dependsOn": "Wartet auf",
   "board.column.due": "Fällig",
   "board.column.labels": "Labels",
@@ -42,17 +49,51 @@
   "board.column.title": "Titel",
   "board.columnEmpty": "Hier ist noch nichts.",
   "board.createFailed": "Die Aufgabe konnte nicht angelegt werden.",
+  "board.drag.lifted": "{card} aufgenommen",
+  "board.drag.moved": "{card} nach {column} verschoben",
+  "board.drag.putBack": "{card} zurückgelegt",
+  "board.dragInstructions": "Eine Karte wird mit der Maus gezogen. Ohne Zeigegerät: Alt halten und eine Pfeiltaste drücken — links und rechts wechseln die Spalte, hoch und runter bewegen innerhalb einer Spalte.",
   "board.failed": "Dieses Board konnte nicht geladen werden.",
   "board.filter.all": "Alle Spalten",
   "board.filter.status": "Spalte zeigen",
   "board.filterEmpty": "Keine Karte passt zu diesem Filter.",
-  "board.group.assignee": "Zuständig",
+  "board.fromDate": "ab {date}",
+  "board.group.empty": "Nichts gesetzt",
   "board.group.none": "Nichts",
-  "board.group.status": "Spalte",
   "board.groupBy": "Gruppieren nach",
+  "board.link.blocker": "Wartet auf",
+  "board.link.outside": "Außerhalb dieses Boards",
+  "board.link.subtask": "Unteraufgabe",
+  "board.links": "Verlinkt",
+  "board.moveTo": "In eine Spalte verschieben",
+  "board.progress": "{done} von {total} erledigt",
+  "board.removeLabel": "Label {label} entfernen",
+  "board.settings.addColumn": "+ Spalte",
+  "board.settings.columnName": "Name der Spalte {column}",
+  "board.settings.description": "Spalten und was das Board zeigt.",
+  "board.settings.duplicateName": "Zwei Spalten heißen {column}. Namen müssen sie unterscheidbar machen.",
+  "board.settings.failed": "Die Einstellungen konnten nicht gespeichert werden.",
+  "board.settings.moveDown": "{column} nach unten",
+  "board.settings.moveUp": "{column} nach oben",
+  "board.settings.newColumn": "Neue Spalte",
+  "board.settings.open": "Board-Einstellungen",
+  "board.settings.remove": "{column} entfernen",
+  "board.settings.removeBlocked": "{column} ist nicht leer. Verschiebe die Karten zuerst.",
+  "board.settings.showArchive": "Archiv-Spalte zeigen",
+  "board.settings.showArchiveHint": "Sie ist auf jedem Board. Ausgeblendet sind ihre Karten überall aus dem Blick.",
+  "board.settings.title": "Board-Einstellungen",
+  "board.stripes.root": "Ebene {level}, hat Unteraufgaben",
+  "board.stripes.under": "Ebene {level} · übergeordnet in {column}",
+  "board.table.collapse": "Verbergen, was unter {row} liegt",
+  "board.table.columns": "Spalten",
+  "board.table.expand": "Zeigen, was unter {row} liegt",
+  "board.table.filteredBy": "nur {column}",
+  "board.table.groupedBy": "gruppiert nach {column}",
   "board.tableEmpty": "Dieses Board hat noch keine Karten.",
+  "board.taskGone": "Diese Karte steht nicht mehr auf diesem Board. Sie ist entweder archiviert oder nicht mehr da.",
   "board.unassigned": "Noch niemand",
   "board.unknownColumn": "nicht auf diesem Board",
+  "board.untilDate": "fällig {date}",
   "board.view.kanban": "Kanban",
   "board.view.table": "Tabelle",
   "common.cancel": "Abbrechen",

package/src/i18n/en.json

@@ -33,8 +33,15 @@
   "auth.signOutFailed": "Signing out failed. Check your connection and try again.",
   "board.addCard": "+ Task",
   "board.addCardIn": "Add a task to {column}",
-  "board.cardLabel": "{title}, in {column}. Hold Alt and use the arrow keys to move it.",
+  "board.addLabel": "Add a label",
+  "board.addLink": "Link",
+  "board.cardLabel": "Open {title}, in {column}. Alt and an arrow key moves it.",
+  "board.column.archive": "Archive",
   "board.column.assignee": "Assigned to",
+  "board.column.default.backlog": "Backlog",
+  "board.column.default.doing": "In progress",
+  "board.column.default.done": "Done",
+  "board.column.default.todo": "To do",
   "board.column.dependsOn": "Waiting for",
   "board.column.due": "Due",
   "board.column.labels": "Labels",
@@ -42,17 +49,51 @@
   "board.column.title": "Title",
   "board.columnEmpty": "Nothing here yet.",
   "board.createFailed": "The task could not be created.",
+  "board.drag.lifted": "{card} picked up",
+  "board.drag.moved": "{card} moved to {column}",
+  "board.drag.putBack": "{card} put back",
+  "board.dragInstructions": "Drag a card with the mouse to move it. Without a pointer, hold Alt and press an arrow key: left and right move the card between columns, up and down within one.",
   "board.failed": "This board could not be loaded.",
   "board.filter.all": "Every column",
   "board.filter.status": "Show column",
   "board.filterEmpty": "No card matches this filter.",
-  "board.group.assignee": "Assigned to",
+  "board.fromDate": "from {date}",
+  "board.group.empty": "Nothing set",
   "board.group.none": "Nothing",
-  "board.group.status": "Column",
   "board.groupBy": "Group by",
+  "board.link.blocker": "Waits for",
+  "board.link.outside": "Outside this board",
+  "board.link.subtask": "Subtask",
+  "board.links": "Linked",
+  "board.moveTo": "Move to a column",
+  "board.progress": "{done} of {total} done",
+  "board.removeLabel": "Remove the label {label}",
+  "board.settings.addColumn": "+ Column",
+  "board.settings.columnName": "Name of the column {column}",
+  "board.settings.description": "Columns and what the board shows.",
+  "board.settings.duplicateName": "Two columns are called {column}. Names have to tell them apart.",
+  "board.settings.failed": "The settings could not be saved.",
+  "board.settings.moveDown": "Move {column} down",
+  "board.settings.moveUp": "Move {column} up",
+  "board.settings.newColumn": "New column",
+  "board.settings.open": "Board settings",
+  "board.settings.remove": "Remove {column}",
+  "board.settings.removeBlocked": "{column} is not empty. Move its cards out first.",
+  "board.settings.showArchive": "Show the archive column",
+  "board.settings.showArchiveHint": "It is on every board. Hidden, its cards are out of sight everywhere.",
+  "board.settings.title": "Board settings",
+  "board.stripes.root": "Level {level}, has subtasks",
+  "board.stripes.under": "Level {level} · parent in {column}",
+  "board.table.collapse": "Hide what is under {row}",
+  "board.table.columns": "Columns",
+  "board.table.expand": "Show what is under {row}",
+  "board.table.filteredBy": "only {column}",
+  "board.table.groupedBy": "grouped by {column}",
   "board.tableEmpty": "This board has no cards yet.",
+  "board.taskGone": "This card is not on this board any more. It may have been archived, or it is gone.",
   "board.unassigned": "Nobody yet",
   "board.unknownColumn": "not on this board",
+  "board.untilDate": "due {date}",
   "board.view.kanban": "Kanban",
   "board.view.table": "Table",
   "common.cancel": "Cancel",