@multiplatform.one/backoffice 6.4.2 → 6.6.0

package/src/list/statusColors.spec.ts

@@ -0,0 +1,100 @@
+/**
+ * statusColors — desk indicator-color parity for the list status pill.
+ * Workflow `states` from the doctype meta must win over the heuristic
+ * word map; everything unknown lands on gray.
+ */
+import { describe, expect, it } from "vitest";
+import type { DoctypeMeta } from "../shared/useDoctypeMeta";
+import { statusPillColors } from "./statusColors";
+
+function makeMeta(states: Array<{ title?: string; color?: string }>): DoctypeMeta {
+  return { name: "ToDo", fields: [], states } as DoctypeMeta;
+}
+
+describe("statusPillColors heuristics (no meta)", () => {
+  it("maps done/healthy words to green", () => {
+    for (const status of ["Closed", "Completed", "Approved", "Paid", "Active", "Delivered"]) {
+      expect(statusPillColors(status)).toEqual({ background: "$green3", text: "$green11" });
+    }
+  });
+
+  it("maps in-flight words to orange", () => {
+    for (const status of ["Open", "Pending", "In Progress", "Overdue", "Medium"]) {
+      expect(statusPillColors(status)).toEqual({ background: "$orange3", text: "$orange11" });
+    }
+  });
+
+  it("maps informational words to blue", () => {
+    for (const status of ["Submitted", "Running", "New", "In Review", "Low"]) {
+      expect(statusPillColors(status)).toEqual({ background: "$blue3", text: "$blue11" });
+    }
+  });
+
+  it("maps failed/stopped words to red", () => {
+    for (const status of ["Cancelled", "Canceled", "Failed", "Rejected", "Urgent", "High"]) {
+      expect(statusPillColors(status)).toEqual({ background: "$red3", text: "$red11" });
+    }
+  });
+
+  it("maps draft and unknown values to gray", () => {
+    expect(statusPillColors("Draft")).toEqual({ background: "$gray3", text: "$gray11" });
+    expect(statusPillColors("Something Custom")).toEqual({
+      background: "$gray3",
+      text: "$gray11",
+    });
+    expect(statusPillColors("")).toEqual({ background: "$gray3", text: "$gray11" });
+  });
+
+  it("normalizes case and whitespace", () => {
+    expect(statusPillColors(" OPEN ")).toEqual({ background: "$orange3", text: "$orange11" });
+    expect(statusPillColors("paid")).toEqual({ background: "$green3", text: "$green11" });
+  });
+});
+
+describe("statusPillColors with workflow states", () => {
+  it("prefers the workflow state color over the word heuristic", () => {
+    // Heuristic would say orange for "Open"; the workflow says Red.
+    const meta = makeMeta([{ title: "Open", color: "Red" }]);
+    expect(statusPillColors("Open", meta)).toEqual({ background: "$red3", text: "$red11" });
+  });
+
+  it("matches state titles case-insensitively and trims", () => {
+    const meta = makeMeta([{ title: "  open ", color: "Green" }]);
+    expect(statusPillColors("Open", meta)).toEqual({ background: "$green3", text: "$green11" });
+  });
+
+  it("maps desk color aliases onto ramp families", () => {
+    const cases: Array<[string, string]> = [
+      ["Light-Blue", "blue"],
+      ["cyan", "blue"],
+      ["Amber", "yellow"],
+      ["Grey", "gray"],
+      ["darkgrey", "gray"],
+      ["Purple", "purple"],
+      ["Pink", "pink"],
+    ];
+    for (const [deskColor, ramp] of cases) {
+      const meta = makeMeta([{ title: "Custom", color: deskColor }]);
+      expect(statusPillColors("Custom", meta)).toEqual({
+        background: `$${ramp}3`,
+        text: `$${ramp}11`,
+      });
+    }
+  });
+
+  it("falls back to the heuristic for unknown desk colors", () => {
+    const meta = makeMeta([{ title: "Open", color: "Teal" }]);
+    expect(statusPillColors("Open", meta)).toEqual({ background: "$orange3", text: "$orange11" });
+  });
+
+  it("falls back to the heuristic when the state has no color or no match", () => {
+    expect(statusPillColors("Open", makeMeta([{ title: "Open" }]))).toEqual({
+      background: "$orange3",
+      text: "$orange11",
+    });
+    expect(statusPillColors("Closed", makeMeta([{ title: "Open", color: "Red" }]))).toEqual({
+      background: "$green3",
+      text: "$green11",
+    });
+  });
+});

package/src/list/statusColors.ts

@@ -0,0 +1,94 @@
+// Desk indicator-color parity: map a status value to theme color tokens for
+// the list-view status pill. Doctype workflow `states` (which carry desk
+// color names) win over the heuristic word map.
+import type { DoctypeMeta } from "../shared/useDoctypeMeta";
+
+export interface StatusPillColors {
+  /** Pill surface (step-3 ramp). */
+  background: string;
+  /** Pill text (step-11 ramp — AA on the step-3 surface). */
+  text: string;
+}
+
+/** Desk indicator color name → tamagui ramp family. */
+const DESK_COLOR_TO_RAMP: Record<string, string> = {
+  red: "red",
+  green: "green",
+  blue: "blue",
+  orange: "orange",
+  yellow: "yellow",
+  amber: "yellow",
+  gray: "gray",
+  grey: "gray",
+  darkgrey: "gray",
+  "light-blue": "blue",
+  purple: "purple",
+  pink: "pink",
+  cyan: "blue",
+};
+
+/** Desk's common listview indicator heuristics (frappe list_view indicators). */
+const STATUS_WORD_TO_RAMP: Record<string, string> = {
+  // green — done / healthy
+  closed: "green",
+  completed: "green",
+  complete: "green",
+  finished: "green",
+  active: "green",
+  enabled: "green",
+  approved: "green",
+  paid: "green",
+  success: "green",
+  resolved: "green",
+  delivered: "green",
+  received: "green",
+  // orange — needs attention / in flight
+  open: "orange",
+  pending: "orange",
+  "in progress": "orange",
+  "to deliver": "orange",
+  "to bill": "orange",
+  overdue: "orange",
+  medium: "orange",
+  // blue — submitted / informational
+  submitted: "blue",
+  running: "blue",
+  new: "blue",
+  "in review": "blue",
+  low: "blue",
+  // red — failed / stopped
+  cancelled: "red",
+  canceled: "red",
+  disabled: "red",
+  failed: "red",
+  rejected: "red",
+  error: "red",
+  expired: "red",
+  inactive: "red",
+  unpaid: "red",
+  lost: "red",
+  high: "red",
+  urgent: "red",
+  // gray — inert
+  draft: "gray",
+};
+
+function rampToPill(ramp: string): StatusPillColors {
+  return { background: `$${ramp}3`, text: `$${ramp}11` };
+}
+
+/**
+ * Resolve the pill colors for a status value. Workflow states from the
+ * doctype meta (desk color names) take precedence; otherwise a heuristic
+ * word map mirrors stock desk indicators; unknown values fall back to gray.
+ */
+export function statusPillColors(status: string, meta?: DoctypeMeta): StatusPillColors {
+  const normalized = status.trim().toLowerCase();
+  const state = meta?.states?.find((s) => (s.title ?? "").trim().toLowerCase() === normalized);
+  if (state?.color) {
+    const ramp = DESK_COLOR_TO_RAMP[state.color.trim().toLowerCase()];
+    if (ramp) return rampToPill(ramp);
+  }
+  const ramp = STATUS_WORD_TO_RAMP[normalized];
+  return rampToPill(ramp ?? "gray");
+}

package/src/navigation/navigator.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { ControlledNavigator, createMemoryNavigator, parseBackofficeHref } from "./navigator";
 
 describe("parseBackofficeHref", () => {
@@ -104,3 +104,132 @@ describe("ControlledNavigator (bridge contract)", () => {
     expect(navigator.getLocation().path).toBe("/backoffice/todo");
   });
 });
+
+describe("ControlledNavigator (navigate-before-mount guard)", () => {
+  // The console-sweep race: one's router throws "Attempted to navigate
+  // before mounting the Root Layout component" for actions issued before
+  // its navigation container mounts — synchronously from back(), and as a
+  // REJECTED PROMISE from push/replace (linkTo is async), which no
+  // caller-side try/catch can see. The navigator must absorb both and
+  // re-dispatch until the host accepts.
+  const NOT_MOUNTED = new Error("Attempted to navigate before mounting the Root Layout component.");
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  /** Flush the promise-rejection microtasks between timer advances. */
+  async function flush(): Promise<void> {
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+  }
+
+  it("retries an async-rejected replace until the host accepts it (no unhandled rejection)", async () => {
+    let mounted = false;
+    const accepted: string[] = [];
+    const replace = vi.fn((path: string) => {
+      if (!mounted) return Promise.reject(NOT_MOUNTED);
+      accepted.push(path);
+      return Promise.resolve();
+    });
+    const navigator = new ControlledNavigator(
+      { navigate: () => {}, replace, back: () => {} },
+      { path: "/backoffice", params: {} },
+    );
+
+    navigator.replace("/backoffice/users");
+    await flush();
+    expect(replace).toHaveBeenCalledTimes(1);
+    expect(accepted).toEqual([]);
+
+    // Router mounts a moment later; the pending action re-dispatches.
+    mounted = true;
+    await vi.advanceTimersByTimeAsync(300);
+    expect(accepted).toEqual(["/backoffice/users"]);
+    expect(replace).toHaveBeenCalledTimes(2);
+
+    // No further re-dispatches once accepted.
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(replace).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries a synchronously-thrown back()", async () => {
+    let mounted = false;
+    const back = vi.fn(() => {
+      if (!mounted) throw NOT_MOUNTED;
+    });
+    const navigator = new ControlledNavigator(
+      { navigate: () => {}, replace: () => {}, back },
+      { path: "/backoffice", params: {} },
+    );
+
+    navigator.back();
+    expect(back).toHaveBeenCalledTimes(1);
+
+    mounted = true;
+    await vi.advanceTimersByTimeAsync(300);
+    expect(back).toHaveBeenCalledTimes(2);
+  });
+
+  it("drops a pending action when the location moves in the meantime", async () => {
+    const replace = vi.fn(() => Promise.reject(NOT_MOUNTED));
+    const navigator = new ControlledNavigator(
+      { navigate: () => {}, replace, back: () => {} },
+      { path: "/backoffice", params: {} },
+    );
+
+    navigator.replace("/backoffice/users");
+    await flush();
+    expect(replace).toHaveBeenCalledTimes(1);
+
+    // A competing navigation landed (host mirrored a new location) — the
+    // stale action must not re-dispatch and yank the user.
+    navigator.setLocation({ path: "/backoffice/todo", params: {} });
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(replace).toHaveBeenCalledTimes(1);
+  });
+
+  it("a newer action supersedes an older pending one", async () => {
+    let mounted = false;
+    const accepted: string[] = [];
+    const impl = (path: string) => {
+      if (!mounted) return Promise.reject(NOT_MOUNTED);
+      accepted.push(path);
+      return Promise.resolve();
+    };
+    const navigator = new ControlledNavigator(
+      { navigate: vi.fn(impl), replace: vi.fn(impl), back: () => {} },
+      { path: "/backoffice", params: {} },
+    );
+
+    navigator.replace("/backoffice/users");
+    await flush();
+    navigator.navigate("/backoffice/todo");
+    await flush();
+
+    mounted = true;
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(accepted).toEqual(["/backoffice/todo"]);
+  });
+
+  it("gives up with a single console.warn after the retry budget", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const replace = vi.fn(() => Promise.reject(NOT_MOUNTED));
+    const navigator = new ControlledNavigator(
+      { navigate: () => {}, replace, back: () => {} },
+      { path: "/backoffice", params: {} },
+    );
+
+    navigator.replace("/backoffice/users");
+    for (let i = 0; i < 60; i++) {
+      await vi.advanceTimersByTimeAsync(250);
+      await flush();
+    }
+    expect(replace.mock.calls.length).toBeLessThanOrEqual(40);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+});

package/src/navigation/navigator.ts

@@ -36,6 +36,14 @@ export interface BackofficeNavigator {
   replace(path: string): void;
   /** Go back one entry. */
   back(): void;
+  /**
+   * Merge query params into the CURRENT location without a new history
+   * entry (desk's `update_url_with_filters` → history.replaceState channel;
+   * one-router `router.setParams`). `undefined` values remove their keys.
+   * Optional — hosts without a param-merge primitive omit it and surfaces
+   * skip URL sync (state still applies locally).
+   */
+  setParams?(params: Record<string, string | undefined>): void;
   /** Snapshot of the current location (stable identity until it changes). */
   getLocation(): BackofficeLocation;
   /** Subscribe to location changes. Returns an unsubscribe function. */
@@ -144,6 +152,18 @@ export class MemoryNavigator extends SubscribableNavigator {
     const top = this.stack[this.stack.length - 1];
     if (top) this.setLocationInternal(top);
   };
+
+  setParams = (params: Record<string, string | undefined>): void => {
+    const current = this.stack[this.stack.length - 1] ?? this.location;
+    const merged: BackofficeParams = { ...current.params };
+    for (const [key, value] of Object.entries(params)) {
+      if (value === undefined) delete merged[key];
+      else merged[key] = value;
+    }
+    const next: BackofficeLocation = { path: current.path, params: merged };
+    this.stack[this.stack.length - 1] = next;
+    this.setLocationInternal(next);
+  };
 }
 
 export function createMemoryNavigator(initialPath = "/backoffice"): MemoryNavigator {
@@ -154,16 +174,38 @@ export interface ControlledNavigatorHandlers {
   navigate(path: string): void;
   replace(path: string): void;
   back(): void;
+  /** Optional param-merge primitive (see {@link BackofficeNavigator.setParams}). */
+  setParams?(params: Record<string, string | undefined>): void;
 }
 
+/** Retry cadence for actions the host router rejected (not mounted yet). */
+const CONTROLLED_RETRY_MS = 250;
+/** Give up re-dispatching a rejected action after this many attempts. */
+const CONTROLLED_RETRY_LIMIT = 40;
+
 /**
  * Bridge navigator for adapters over an external router: navigation calls
  * forward to the host handlers, and the host mirrors its location back via
  * {@link ControlledNavigator.setLocation}. The one-adapter is ~20 lines over
  * this class; a react-router or seam adapter looks the same.
+ *
+ * Handler calls are dispatched through a not-ready guard: a host router can
+ * reject an action issued before its navigation container mounts — one's
+ * router throws "Attempted to navigate before mounting the Root Layout
+ * component", and because its `linkTo` is async the throw surfaces as an
+ * UNHANDLED PROMISE REJECTION that no caller-side try/catch can see (the
+ * boot-time redirect race from the console sweep, 4×/session). The guard
+ * traps sync throws and async rejections, then re-dispatches the action on
+ * an interval until the host accepts it — unless the location moved in the
+ * meantime (a competing navigation landed; the stale action is dropped).
  */
 export class ControlledNavigator extends SubscribableNavigator {
   private handlers: ControlledNavigatorHandlers;
+  private retryTimer: ReturnType<typeof setTimeout> | undefined;
+  /** Monotonic dispatch id — a rejection only re-arms its action while that
+   * action is still the newest one (stale rejections arrive on microtasks
+   * and could otherwise resurrect a superseded navigation). */
+  private dispatchSeq = 0;
 
   constructor(handlers: ControlledNavigatorHandlers, initialLocation?: BackofficeLocation) {
     super(initialLocation ?? { path: "/", params: {} });
@@ -181,16 +223,64 @@ export class ControlledNavigator extends SubscribableNavigator {
   }
 
   navigate = (path: string): void => {
-    this.handlers.navigate(path);
+    this.dispatch(() => this.handlers.navigate(path), `navigate(${path})`);
   };
 
   replace = (path: string): void => {
-    this.handlers.replace(path);
+    this.dispatch(() => this.handlers.replace(path), `replace(${path})`);
   };
 
   back = (): void => {
-    this.handlers.back();
+    this.dispatch(() => this.handlers.back(), "back()");
+  };
+
+  // Best-effort, NOT routed through the retry dispatcher: URL sync is a
+  // cosmetic mirror of state that already applied locally — a write the
+  // router rejects (pre-mount) has nothing to sync yet, and a retried stale
+  // write could clobber a newer one. Pokemon-list precedent (try/catch
+  // around router.setParams).
+  setParams = (params: Record<string, string | undefined>): void => {
+    try {
+      this.handlers.setParams?.(params);
+    } catch {
+      // host router not ready / no params support — state stays local
+    }
   };
+
+  private dispatch(action: () => unknown, label: string, attempt = 0): void {
+    // The newest intent supersedes any action still waiting on a retry.
+    if (this.retryTimer !== undefined) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = undefined;
+    }
+    const seq = ++this.dispatchSeq;
+    const issuedAt = this.location;
+    const superseded = () => seq !== this.dispatchSeq || this.location !== issuedAt;
+    const scheduleRetry = (error: unknown) => {
+      if (superseded()) return; // a newer action or navigation landed
+      if (attempt + 1 >= CONTROLLED_RETRY_LIMIT) {
+        console.warn(`[backoffice] navigation ${label} never accepted by the host router:`, error);
+        return;
+      }
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = undefined;
+        if (superseded()) return;
+        this.dispatch(action, label, attempt + 1);
+      }, CONTROLLED_RETRY_MS);
+    };
+    let result: unknown;
+    try {
+      result = action();
+    } catch (error) {
+      scheduleRetry(error);
+      return;
+    }
+    // Host handlers may return a promise (one's router.push/replace are
+    // async); a pre-mount rejection is only observable here.
+    if (result && typeof (result as PromiseLike<unknown>).then === "function") {
+      Promise.resolve(result).catch(scheduleRetry);
+    }
+  }
 }
 
 /**

package/src/navigation/paths.spec.ts

@@ -0,0 +1,156 @@
+/**
+ * navigation — slug + path builder contracts.
+ *
+ * NOTE: newDocPath may concurrently gain an optional defaults argument
+ * (`?d=<urlencoded JSON>` prefill). The no-arg form is the stable contract
+ * pinned exactly; the with-arg form is asserted tolerantly (works both
+ * before and after that change lands).
+ */
+import { describe, expect, it } from "vitest";
+import {
+  BACKOFFICE_BASE,
+  BACKOFFICE_VIEWS,
+  createBackofficePaths,
+  formPath,
+  homePath,
+  isBackofficeView,
+  listPath,
+  newDocPath,
+  queryReportPath,
+  slugToDisplayName,
+  toSlug,
+  viewPath,
+  workspacePath,
+} from "./paths";
+
+describe("toSlug", () => {
+  it("lowercases and dashes spaces like frappe.router.slug", () => {
+    expect(toSlug("Sales Order")).toBe("sales-order");
+    expect(toSlug("ToDo")).toBe("todo");
+    expect(toSlug("User")).toBe("user");
+    expect(toSlug("Purchase Order Item")).toBe("purchase-order-item");
+  });
+
+  it("leaves already-slugged input unchanged", () => {
+    expect(toSlug("sales-order")).toBe("sales-order");
+  });
+});
+
+describe("slugToDisplayName", () => {
+  it("title-cases dash-separated slugs", () => {
+    expect(slugToDisplayName("sales-order")).toBe("Sales Order");
+    expect(slugToDisplayName("user")).toBe("User");
+  });
+
+  it("is best-effort only for intra-word capitals (todo → Todo, not ToDo)", () => {
+    // Real casing is resolved data-driven via useSlugTarget; this documents
+    // the fallback (bench-verified: "todo" falls back to "Todo").
+    expect(slugToDisplayName("todo")).toBe("Todo");
+  });
+});
+
+describe("slug round-trips", () => {
+  it("round-trips space-separated title-case names", () => {
+    for (const name of ["Sales Order", "User", "Purchase Order Item", "Note"]) {
+      expect(slugToDisplayName(toSlug(name))).toBe(name);
+    }
+  });
+
+  it("round-trips any well-formed slug through the display name", () => {
+    for (const slug of ["sales-order", "todo", "user", "purchase-order-item"]) {
+      expect(toSlug(slugToDisplayName(slug))).toBe(slug);
+    }
+  });
+});
+
+describe("path builders", () => {
+  it("homePath returns the base", () => {
+    expect(homePath()).toBe("/backoffice");
+    expect(BACKOFFICE_BASE).toBe("/backoffice");
+  });
+
+  it("workspacePath slugs the workspace name", () => {
+    expect(workspacePath("Users")).toBe("/backoffice/users");
+    expect(workspacePath("Reports & Masters")).toBe("/backoffice/reports-&-masters");
+  });
+
+  it("listPath slugs the doctype", () => {
+    expect(listPath("Sales Order")).toBe("/backoffice/sales-order");
+    expect(listPath("ToDo")).toBe("/backoffice/todo");
+  });
+
+  it("viewPath routes list to the plain list path and other views under /view/", () => {
+    expect(viewPath("ToDo", "list")).toBe("/backoffice/todo");
+    expect(viewPath("ToDo", "kanban")).toBe("/backoffice/todo/view/kanban");
+    expect(viewPath("Sales Order", "report")).toBe("/backoffice/sales-order/view/report");
+    expect(viewPath("Event", "calendar")).toBe("/backoffice/event/view/calendar");
+  });
+
+  it("newDocPath (no defaults) is the stable /new route", () => {
+    expect(newDocPath("ToDo")).toBe("/backoffice/todo/new");
+    expect(newDocPath("Sales Order")).toBe("/backoffice/sales-order/new");
+  });
+
+  it("newDocPath with a defaults argument still targets the /new route", () => {
+    // Tolerant: before the prefill change extra args are ignored (exact
+    // /new path); after it, defaults serialize into a ?d= query param.
+    const result = (newDocPath as (doctype: string, defaults?: Record<string, unknown>) => string)(
+      "ToDo",
+      { status: "Open" },
+    );
+    expect(result === "/backoffice/todo/new" || result.startsWith("/backoffice/todo/new?")).toBe(
+      true,
+    );
+  });
+
+  it("formPath URI-encodes the document name", () => {
+    expect(formPath("ToDo", "abc123")).toBe("/backoffice/todo/abc123");
+    expect(formPath("User", "test@example.com")).toBe("/backoffice/user/test%40example.com");
+    expect(formPath("Sales Order", "SAL-ORD-2026-00001")).toBe(
+      "/backoffice/sales-order/SAL-ORD-2026-00001",
+    );
+    // Names containing a slash must not create extra route segments.
+    expect(formPath("Item", "A/B")).toBe("/backoffice/item/A%2FB");
+  });
+
+  it("queryReportPath URI-encodes the report name", () => {
+    expect(queryReportPath("Permitted Documents For User")).toBe(
+      "/backoffice/query-report/Permitted%20Documents%20For%20User",
+    );
+  });
+
+  it("createBackofficePaths binds every builder to the mount prefix", () => {
+    const paths = createBackofficePaths("/desk");
+    expect(paths.home()).toBe("/desk");
+    expect(paths.workspace("Users")).toBe("/desk/users");
+    expect(paths.list("Sales Order")).toBe("/desk/sales-order");
+    expect(paths.view("ToDo", "kanban")).toBe("/desk/todo/view/kanban");
+    expect(paths.newDoc("ToDo")).toBe("/desk/todo/new");
+    expect(paths.form("User", "test@example.com")).toBe("/desk/user/test%40example.com");
+    expect(paths.queryReport("My Report")).toBe("/desk/query-report/My%20Report");
+  });
+});
+
+describe("isBackofficeView", () => {
+  it("accepts every declared view", () => {
+    expect(BACKOFFICE_VIEWS).toEqual([
+      "list",
+      "report",
+      "kanban",
+      "calendar",
+      "tree",
+      "image",
+      "dashboard",
+    ]);
+    for (const view of BACKOFFICE_VIEWS) {
+      expect(isBackofficeView(view)).toBe(true);
+    }
+  });
+
+  it("rejects unknown or wrongly-cased values", () => {
+    expect(isBackofficeView("grid")).toBe(false);
+    expect(isBackofficeView("List")).toBe(false);
+    expect(isBackofficeView("")).toBe(false);
+    expect(isBackofficeView("kanban ")).toBe(false);
+  });
+});

package/src/navigation/paths.ts

@@ -92,6 +92,8 @@ export interface BackofficePaths {
    */
   newDoc(doctype: string, defaults?: Record<string, unknown>): string;
   form(doctype: string, name: string): string;
+  /** Query/Script Report page (desk /app/query-report/<name>). */
+  queryReport(reportName: string): string;
 }
 
 export function createBackofficePaths(basePath: string = BACKOFFICE_BASE): BackofficePaths {
@@ -112,6 +114,7 @@ export function createBackofficePaths(basePath: string = BACKOFFICE_BASE): Backo
       return `${path}?d=${encodeURIComponent(JSON.stringify(defaults))}`;
     },
     form: (doctype, name) => `${prefix}/${toSlug(doctype)}/${encodeURIComponent(name)}`,
+    queryReport: (reportName) => `${prefix}/query-report/${encodeURIComponent(reportName)}`,
   };
 }
 
@@ -144,3 +147,10 @@ export function newDocPath(doctype: string, defaults?: Record<string, unknown>):
 export function formPath(doctype: string, name: string): BackofficeSubPath {
   return defaultPaths.form(doctype, name) as BackofficeSubPath;
 }
+
+export const QUERY_REPORT_BASE = "/backoffice/query-report";
+
+/** `/backoffice/query-report/<encoded report name>` (desk /app/query-report/<name>). */
+export function queryReportPath(reportName: string): BackofficeSubPath {
+  return defaultPaths.queryReport(reportName) as BackofficeSubPath;
+}