@multiplatform.one/backoffice 6.3.0 → 6.4.1

package/src/workspace/parseContent.ts

@@ -0,0 +1,240 @@
+/**
+ * Pure parsing helpers for the Workspace `content` block JSON and the
+ * JSON filter strings carried by shortcuts / quick lists / number cards.
+ * No DOM: HTML in header/paragraph blocks is stripped with a regex-based
+ * text extractor so this runs on native and gjs too.
+ */
+import type {
+  FrappeFilterTuple,
+  WorkspaceBlock,
+  WorkspaceDoc,
+  WorkspaceLinkGroup,
+  WorkspaceLinkRow,
+} from "./types";
+
+/** Parse the workspace `content` JSON string into blocks (bad JSON → []). */
+export function parseWorkspaceContent(content: string | undefined | null): WorkspaceBlock[] {
+  if (!content) return [];
+  try {
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (block): block is WorkspaceBlock =>
+        !!block && typeof block === "object" && typeof block.type === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+const NAMED_ENTITIES: Record<string, string> = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+};
+
+/**
+ * Extract plain text from desk's rich-text wrappers, e.g.
+ * `<span class="h4"><b>Reports &amp; Masters</b></span>` → "Reports & Masters".
+ */
+export function stripHtml(html: string | undefined | null): string {
+  if (!html) return "";
+  const withoutTags = html.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]*>/g, "");
+  return withoutTags
+    .replace(/&(#[xX]?[0-9a-fA-F]+|[a-zA-Z]+);/g, (match, entity: string) => {
+      if (entity.startsWith("#x") || entity.startsWith("#X")) {
+        const code = Number.parseInt(entity.slice(2), 16);
+        return Number.isNaN(code) ? match : String.fromCodePoint(code);
+      }
+      if (entity.startsWith("#")) {
+        const code = Number.parseInt(entity.slice(1), 10);
+        return Number.isNaN(code) ? match : String.fromCodePoint(code);
+      }
+      return NAMED_ENTITIES[entity.toLowerCase()] ?? match;
+    })
+    .trim();
+}
+
+/**
+ * Heading level from a desk header block's HTML wrapper: `class="h4"` →
+ * 4. Desk also emits raw font-size styles (Build workspace uses
+ * `font-size: 18px`); those and unclassed headers fall back to 4 — the
+ * visual scale desk uses for workspace section headings.
+ */
+export function headerLevel(html: string | undefined | null): 1 | 2 | 3 | 4 | 5 | 6 {
+  const match = (html ?? "").match(/class="[^"]*\bh([1-6])\b[^"]*"/);
+  if (match) return Number(match[1]) as 1 | 2 | 3 | 4 | 5 | 6;
+  return 4;
+}
+
+/**
+ * Group the flat `links` child table into cards: each "Card Break" row
+ * opens a group that collects the following "Link" rows (hidden rows are
+ * dropped). Link rows before any Card Break are ignored — desk does the
+ * same (they are unreachable from card blocks).
+ */
+export function groupLinks(links: WorkspaceLinkRow[] | undefined): WorkspaceLinkGroup[] {
+  const groups: WorkspaceLinkGroup[] = [];
+  let current: WorkspaceLinkGroup | undefined;
+  for (const row of links ?? []) {
+    if (row.type === "Card Break") {
+      // A hidden Card Break hides its whole card: close the current group so
+      // its following Link rows are dropped, not leaked into the prior card.
+      if (row.hidden) {
+        current = undefined;
+        continue;
+      }
+      current = { label: row.label, breakRow: row, links: [] };
+      groups.push(current);
+    } else if (row.type === "Link" && current && !row.hidden) {
+      current.links.push(row);
+    }
+  }
+  return groups;
+}
+
+/**
+ * Normalize a frappe JSON filter string to `[field, op, value]` triples.
+ * Real-world shapes (all seen on the control bench):
+ * - dict: `{"status":"Open"}` → `[["status","=","Open"]]`
+ * - dict of tuples: `{"status":["=","Open"]}` → `[["status","=","Open"]]`
+ * - list of triples: `[["enabled","=",1]]` → as-is
+ * - list of quads (doctype-prefixed, Number Card `filters_json`):
+ *   `[["User","enabled","=",1]]` → doctype element stripped.
+ */
+export function parseFrappeFilters(
+  raw: string | undefined | null,
+): FrappeFilterTuple[] | undefined {
+  if (!raw) return undefined;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+  if (Array.isArray(parsed)) {
+    const tuples: FrappeFilterTuple[] = [];
+    for (const entry of parsed) {
+      if (!Array.isArray(entry)) continue;
+      if (entry.length >= 4) {
+        // [doctype, field, op, value] — drop the doctype element.
+        tuples.push([String(entry[1]), String(entry[2]), entry[3]]);
+      } else if (entry.length === 3) {
+        tuples.push([String(entry[0]), String(entry[1]), entry[2]]);
+      }
+    }
+    return tuples.length > 0 ? tuples : undefined;
+  }
+  if (parsed && typeof parsed === "object") {
+    const tuples: FrappeFilterTuple[] = [];
+    for (const [field, value] of Object.entries(parsed as Record<string, unknown>)) {
+      if (Array.isArray(value) && value.length === 2 && typeof value[0] === "string") {
+        tuples.push([field, value[0], value[1]]);
+      } else {
+        tuples.push([field, "=", value]);
+      }
+    }
+    return tuples.length > 0 ? tuples : undefined;
+  }
+  return undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Dashboard-first composition (MOD-11)
+// ---------------------------------------------------------------------------
+
+/**
+ * Workspace blocks partitioned by class for the dashboard-first layout:
+ * data widgets render first, then shortcuts, then the link-card directory.
+ */
+export interface WorkspaceComposition {
+  /**
+   * Live data widgets, ordered number cards → charts → quick lists
+   * (authored order within each class).
+   */
+  data: WorkspaceBlock[];
+  /** Shortcut blocks in authored order. */
+  shortcuts: WorkspaceBlock[];
+  /** Link-card blocks in authored order. */
+  cards: WorkspaceBlock[];
+  /**
+   * Narrative content in authored order: paragraphs, plus headers that do
+   * NOT label a widget run (see keep rule below). Section-label headers
+   * ("Your Shortcuts", "Reports & Masters") are dropped — the recomposed
+   * sections carry their own canonical headings.
+   */
+  text: WorkspaceBlock[];
+}
+
+const DATA_BLOCK_RANK: Record<string, number> = { number_card: 0, chart: 1, quick_list: 2 };
+
+function isDataBlock(block: WorkspaceBlock): boolean {
+  return block.type in DATA_BLOCK_RANK;
+}
+
+/**
+ * Partition parsed content blocks for the dashboard-first workspace layout
+ * (data → shortcuts → link cards), instead of desk's authoring order.
+ *
+ * Header keep rule: a header labels the blocks that follow it up to the next
+ * header. If that run contains any widget block (shortcut, card, chart,
+ * number card, quick list, onboarding, custom block), the header is a section
+ * label and is dropped; if the run holds only paragraphs (or nothing — e.g.
+ * the text-only "Welcome Workspace"), the header is real content and is kept.
+ * Spacers are dropped — section spacing owns the rhythm.
+ */
+export function composeWorkspaceBlocks(blocks: WorkspaceBlock[]): WorkspaceComposition {
+  const shortcuts: WorkspaceBlock[] = [];
+  const cards: WorkspaceBlock[] = [];
+  const text: WorkspaceBlock[] = [];
+  const dataBlocks: WorkspaceBlock[] = [];
+
+  for (const [index, block] of blocks.entries()) {
+    if (isDataBlock(block)) {
+      dataBlocks.push(block);
+    } else if (block.type === "shortcut") {
+      shortcuts.push(block);
+    } else if (block.type === "card") {
+      cards.push(block);
+    } else if (block.type === "paragraph") {
+      text.push(block);
+    } else if (block.type === "header") {
+      let labelsWidgets = false;
+      for (const following of blocks.slice(index + 1)) {
+        if (following.type === "header") break;
+        if (following.type === "paragraph" || following.type === "spacer") continue;
+        labelsWidgets = true;
+        break;
+      }
+      if (!labelsWidgets) text.push(block);
+    }
+    // spacer / onboarding / custom_block / unknown — dropped (see module doc).
+  }
+
+  // Stable class ordering: number cards → charts → quick lists.
+  const data = dataBlocks
+    .map((block, index) => ({ block, index }))
+    .sort(
+      (a, b) =>
+        (DATA_BLOCK_RANK[a.block.type] ?? 0) - (DATA_BLOCK_RANK[b.block.type] ?? 0) ||
+        a.index - b.index,
+    )
+    .map(({ block }) => block);
+
+  return { data, shortcuts, cards, text };
+}
+
+/** Find a workspace shortcut row by a shortcut block's `shortcut_name`. */
+export function findShortcut(doc: WorkspaceDoc, shortcutName: string | undefined) {
+  if (!shortcutName) return undefined;
+  return doc.shortcuts?.find((row) => row.label === shortcutName);
+}
+
+/** Find a link group by a card block's `card_name`. */
+export function findLinkGroup(groups: WorkspaceLinkGroup[], cardName: string | undefined) {
+  if (!cardName) return undefined;
+  return groups.find((group) => group.label === cardName);
+}

package/src/workspace/types.ts

@@ -0,0 +1,135 @@
+/**
+ * Frappe Workspace doc shapes — verified against a real bench
+ * (`GET /api/resource/Workspace/<name>`; see WorkspaceScreen for the
+ * rendering contract). `content` is an editorjs-style JSON string of
+ * blocks; the child tables hold the referenced widget definitions.
+ */
+
+/** One row of the `shortcuts` child table (doctype "Workspace Shortcut"). */
+export interface WorkspaceShortcutRow {
+  name: string;
+  /** "DocType" | "Report" | "Page" | "Dashboard" | "URL" */
+  type: string;
+  link_to?: string;
+  /** URL shortcuts put the target here. */
+  url?: string;
+  label: string;
+  /** Optional list-view variant, e.g. "List" | "Tree" | "Report Builder". */
+  doc_view?: string;
+  /** Frappe color name for the count pill, e.g. "Grey", "Blue". */
+  color?: string;
+  /** JSON filters for the live count, e.g. `{"status":"Open"}`. */
+  stats_filter?: string;
+  /** Count display template, `{}` is the count, e.g. `"{} Open"`. */
+  format?: string;
+}
+
+/** One row of the `links` child table (doctype "Workspace Link"). */
+export interface WorkspaceLinkRow {
+  name: string;
+  /** "Card Break" starts a link group; "Link" is a member of the group. */
+  type: "Card Break" | "Link" | string;
+  label: string;
+  /** "DocType" | "Report" | "Page" — only on type "Link". */
+  link_type?: string;
+  link_to?: string;
+  hidden?: number;
+  onboard?: number;
+  is_query_report?: number;
+  /** On Card Break rows: number of links desk shows before "+ N more". */
+  link_count?: number;
+  dependencies?: string;
+}
+
+/** One row of the `charts` child table (doctype "Workspace Chart"). */
+export interface WorkspaceChartRow {
+  name: string;
+  /** Dashboard Chart doc name. */
+  chart_name: string;
+  label?: string;
+}
+
+/** One row of the `number_cards` child table (doctype "Workspace Number Card"). */
+export interface WorkspaceNumberCardRow {
+  name: string;
+  /** Number Card doc name. */
+  number_card_name: string;
+  label?: string;
+}
+
+/** One row of the `quick_lists` child table (doctype "Workspace Quick List"). */
+export interface WorkspaceQuickListRow {
+  name: string;
+  document_type: string;
+  label?: string;
+  /** JSON filters, e.g. `{"status":["=","Open"]}`. */
+  quick_list_filter?: string;
+}
+
+/** The Workspace document (fields the workspace page renders). */
+export interface WorkspaceDoc {
+  name: string;
+  doctype: string;
+  title?: string;
+  label?: string;
+  icon?: string;
+  module?: string;
+  public?: number;
+  is_hidden?: number;
+  /** JSON string of editorjs-style blocks. */
+  content?: string;
+  shortcuts?: WorkspaceShortcutRow[];
+  links?: WorkspaceLinkRow[];
+  charts?: WorkspaceChartRow[];
+  number_cards?: WorkspaceNumberCardRow[];
+  quick_lists?: WorkspaceQuickListRow[];
+  [key: string]: unknown;
+}
+
+// ---------------------------------------------------------------------------
+// Parsed `content` blocks
+// ---------------------------------------------------------------------------
+
+export type WorkspaceBlockType =
+  | "header"
+  | "paragraph"
+  | "shortcut"
+  | "card"
+  | "chart"
+  | "number_card"
+  | "quick_list"
+  | "spacer"
+  | "onboarding"
+  | (string & {});
+
+export interface WorkspaceBlock {
+  id: string;
+  type: WorkspaceBlockType;
+  data: {
+    /** header / paragraph: HTML-ish rich text. */
+    text?: string;
+    /** shortcut: matches `shortcuts[].label`. */
+    shortcut_name?: string;
+    /** card: matches a Card Break `links[].label`. */
+    card_name?: string;
+    /** chart: matches `charts[].chart_name`. */
+    chart_name?: string;
+    /** number_card: matches `number_cards[].number_card_name`. */
+    number_card_name?: string;
+    /** quick_list: matches `quick_lists[].document_type`. */
+    quick_list_name?: string;
+    /** 12-column grid span (3 = shortcut pill, 4 = card, 12 = full row). */
+    col?: number;
+    [key: string]: unknown;
+  };
+}
+
+/** A Card Break row grouped together with its following Link rows. */
+export interface WorkspaceLinkGroup {
+  label: string;
+  breakRow: WorkspaceLinkRow;
+  links: WorkspaceLinkRow[];
+}
+
+/** Frappe filter triple, ready for the frappe client (`[field, op, value]`). */
+export type FrappeFilterTuple = [string, string, unknown];

package/src/workspace/useDashboardChart.ts

@@ -0,0 +1,115 @@
+/**
+ * Dashboard Chart data for workspace chart blocks.
+ *
+ * Desk fetches chart data through the whitelisted RPC
+ * `frappe.desk.doctype.dashboard_chart.dashboard_chart.get` (POST with
+ * `chart_name`), which returns `{message: {labels: string[], datasets:
+ * [{name, values: number[]}]}}` — verified against the control bench.
+ * The chart *type* (Line/Bar/Pie/…) lives on the Dashboard Chart doc,
+ * which the block reads separately via `useFrappeDoc`.
+ *
+ * Fixture mode has no RPC surface — the hook reports `unsupported` and
+ * the block renders an informational card instead (documented gap).
+ */
+import { CallModule, HttpClient, type AuthConfig } from "@multiplatform.one/frappe";
+import { useFrappeConfig, type FrappeConfig } from "@multiplatform.one/frappe-ui";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export interface DashboardChartSeries {
+  labels: string[];
+  datasets: Array<{ name?: string; values: number[] }>;
+}
+
+export interface DashboardChartDoc {
+  name: string;
+  doctype: string;
+  chart_name?: string;
+  /** Render style: "Line" | "Bar" | "Percentage" | "Pie" | "Donut" | "Heatmap" */
+  type?: string;
+  /** Data source kind: "Count" | "Sum" | "Average" | "Group By" | "Report" | "Custom" */
+  chart_type?: string;
+  document_type?: string;
+  [key: string]: unknown;
+}
+
+export interface UseDashboardChartDataResult {
+  series: DashboardChartSeries | undefined;
+  isLoading: boolean;
+  error: Error | undefined;
+  /** Fixture mode (stories/tests) — no RPC available for chart data. */
+  unsupported: boolean;
+  refresh: () => void;
+}
+
+const callCache = new Map<string, CallModule>();
+
+function getCall(config: FrappeConfig): CallModule {
+  const key = `${config.baseURL}:${config.auth?.token ?? ""}:${config.auth?.type ?? ""}`;
+  let call = callCache.get(key);
+  if (!call) {
+    const authConfig: AuthConfig | undefined = config.auth
+      ? {
+          useToken: config.auth.useToken,
+          token: config.auth.token,
+          type: config.auth.type as AuthConfig["type"],
+        }
+      : undefined;
+    call = new CallModule(new HttpClient(config.baseURL, authConfig));
+    callCache.set(key, call);
+  }
+  return call;
+}
+
+const CHART_GET_METHOD = "frappe.desk.doctype.dashboard_chart.dashboard_chart.get";
+
+/** Fetch a Dashboard Chart's series via the desk RPC (live mode only). */
+export function useDashboardChartData(chartName: string | undefined): UseDashboardChartDataResult {
+  const config = useFrappeConfig();
+  const [series, setSeries] = useState<DashboardChartSeries | undefined>(undefined);
+  const [isLoading, setIsLoading] = useState(!!chartName && !config?.fixtures);
+  const [error, setError] = useState<Error | undefined>(undefined);
+  const fetchSeq = useRef(0);
+
+  const configRef = useRef(config);
+  configRef.current = config;
+
+  const unsupported = !!config?.fixtures;
+
+  const runFetch = useCallback(async (name: string) => {
+    const conn = configRef.current;
+    if (conn?.fixtures) return;
+    const seq = ++fetchSeq.current;
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      if (!conn?.baseURL) {
+        throw new Error("useDashboardChartData requires a FrappeProvider with baseURL");
+      }
+      const res = await getCall(conn).post<{ message: DashboardChartSeries }>(CHART_GET_METHOD, {
+        chart_name: name,
+        refresh: 1,
+      });
+      if (seq !== fetchSeq.current) return;
+      setSeries(res.payload.message);
+    } catch (err) {
+      if (seq !== fetchSeq.current) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (seq === fetchSeq.current) setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!chartName || unsupported) {
+      setIsLoading(false);
+      return;
+    }
+    void runFetch(chartName);
+  }, [chartName, unsupported, runFetch, config?.baseURL]);
+
+  const refresh = useCallback(() => {
+    if (chartName) void runFetch(chartName);
+  }, [chartName, runFetch]);
+
+  return { series, isLoading, error, unsupported, refresh };
+}

package/src/workspace/useWorkspaceDoc.ts

@@ -0,0 +1,111 @@
+/**
+ * Single-doc fetch for the workspace page.
+ *
+ * A Workspace doc is read-mostly chrome (its child tables define the page
+ * layout), so a plain REST `getDoc` through the frappe client is a better
+ * fit than spinning up a live collection for one document. Honors the
+ * FrappeProvider's fixture provider so stories/tests run offline.
+ */
+import { DbModule, HttpClient, type AuthConfig } from "@multiplatform.one/frappe";
+import { useFrappeConfig, type FrappeConfig } from "@multiplatform.one/frappe-ui";
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { WorkspaceDoc } from "./types";
+
+// One REST client per connection — screens sharing a bench share it.
+const dbCache = new Map<string, DbModule>();
+
+function getDb(config: FrappeConfig): DbModule {
+  const key = `${config.baseURL}:${config.auth?.token ?? ""}:${config.auth?.type ?? ""}`;
+  let db = dbCache.get(key);
+  if (!db) {
+    const authConfig: AuthConfig | undefined = config.auth
+      ? {
+          useToken: config.auth.useToken,
+          token: config.auth.token,
+          type: config.auth.type as AuthConfig["type"],
+        }
+      : undefined;
+    db = new DbModule(new HttpClient(config.baseURL, authConfig));
+    dbCache.set(key, db);
+  }
+  return db;
+}
+
+export interface UseFrappeDocResult<TDoc> {
+  doc: TDoc | undefined;
+  /** First load in flight — render a skeleton. */
+  isLoading: boolean;
+  error: Error | undefined;
+  /** True when the server rejected the read (HTTP 403). */
+  isPermissionError: boolean;
+  refresh: () => void;
+}
+
+/** Fetch one document via REST (or the provider's fixtures when present). */
+export function useFrappeDoc<TDoc extends { name: string; doctype: string }>(
+  doctype: string,
+  name: string | undefined,
+): UseFrappeDocResult<TDoc> {
+  const config = useFrappeConfig();
+  const [doc, setDoc] = useState<TDoc | undefined>(undefined);
+  const [isLoading, setIsLoading] = useState(!!name);
+  const [error, setError] = useState<Error | undefined>(undefined);
+  const fetchSeq = useRef(0);
+
+  const configRef = useRef(config);
+  configRef.current = config;
+
+  const runFetch = useCallback(
+    async (docName: string) => {
+      const conn = configRef.current;
+      const seq = ++fetchSeq.current;
+      setIsLoading(true);
+      setError(undefined);
+      try {
+        let result: TDoc | undefined;
+        if (conn?.fixtures) {
+          const fixtureDoc = await conn.fixtures.getDoc(doctype, docName);
+          if (!fixtureDoc) throw new Error(`${doctype} ${docName} not found`);
+          result = fixtureDoc as unknown as TDoc;
+        } else if (conn?.baseURL) {
+          result = (await getDb(conn).getDoc(doctype, docName)) as unknown as TDoc;
+        } else {
+          throw new Error("useFrappeDoc requires a FrappeProvider with baseURL or fixtures");
+        }
+        if (seq !== fetchSeq.current) return;
+        setDoc(result);
+      } catch (err) {
+        if (seq !== fetchSeq.current) return;
+        setDoc(undefined);
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (seq === fetchSeq.current) setIsLoading(false);
+      }
+      // doctype is stable per hook usage; config flows through configRef.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    },
+    [doctype],
+  );
+
+  useEffect(() => {
+    if (!name) {
+      setDoc(undefined);
+      setIsLoading(false);
+      return;
+    }
+    void runFetch(name);
+  }, [name, runFetch, config?.baseURL, config?.fixtures]);
+
+  const refresh = useCallback(() => {
+    if (name) void runFetch(name);
+  }, [name, runFetch]);
+
+  const isPermissionError = (error as { status?: number } | undefined)?.status === 403;
+
+  return { doc, isLoading, error, isPermissionError, refresh };
+}
+
+/** Fetch a Workspace doc by proper-cased name (e.g. "Home", "Users"). */
+export function useWorkspaceDoc(workspace: string): UseFrappeDocResult<WorkspaceDoc> {
+  return useFrappeDoc<WorkspaceDoc>("Workspace", workspace);
+}

package/types/chrome/CommandPalette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CommandPalette.d.ts","sourceRoot":"","sources":["../../src/chrome/CommandPalette.tsx"],"names":[],"mappings":"AAwDA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACvC;AAED,wBAAgB,cAAc,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,mBAAmB,2CAyPzE"}
+{"version":3,"file":"CommandPalette.d.ts","sourceRoot":"","sources":["../../src/chrome/CommandPalette.tsx"],"names":[],"mappings":"AAwDA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACvC;AAED,wBAAgB,cAAc,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,mBAAmB,2CA6QzE"}

package/types/i18n/en.d.ts

@@ -61,6 +61,25 @@ export declare const en: {
         readonly exitToSite: "← multiplatform.one";
         readonly logOut: "Log Out";
     };
+    readonly loading: "Loading";
+    readonly workspaceCardEmpty: "No links in this section";
+    readonly workspaceShortcutUnavailable: "Not available";
+    readonly workspaceQuickListViewAll: "View All";
+    readonly workspaceNumberCardError: "Couldn't load number card";
+    readonly workspaceNumberCardUnsupported: "This card type is only available in desk";
+    readonly workspaceChartFixture: "Chart data is only available on a live bench";
+    readonly workspaceChartError: "Couldn't load chart {{title}}";
+    readonly workspaceBrowseAll: "Browse all";
+    readonly workspaceBrowseAllCount_one: "{{count}} link";
+    readonly workspaceBrowseAllCount_other: "{{count}} links";
+    readonly workspaceFilterLinks: "Filter links...";
+    readonly workspaceFilterNoMatch: "No links match \"{{query}}\"";
+    readonly workspaceRecents: "Continue where you left off";
+    readonly workspacePermissionError: "You do not have permission to view {{workspace}}";
+    readonly workspaceError: "Couldn't load workspace {{workspace}}";
+    readonly workspaceEmpty: "This workspace is empty";
+    readonly workspaceEmptyDescription: "No blocks have been added to {{workspace}} yet";
+    readonly workspaceShortcuts: "Shortcuts";
     readonly help: {
         readonly label: "Help";
         readonly documentation: "Documentation";

package/types/i18n/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/i18n/en.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EL,CAAC"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/i18n/en.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+FL,CAAC"}

package/types/index.d.ts

@@ -52,4 +52,38 @@ export type { SessionUserInfo } from "./chrome/user-session";
 export { useBackofficeShortcuts } from "./chrome/shortcuts";
 export type { BackofficeShortcutHandlers } from "./chrome/shortcuts";
 export { useFrappeApp } from "./shared/useFrappeApp";
+export type { FrappeFilter, FrappeFilters, SlugTarget } from "./shared/types";
+export { useDoctypeMeta } from "./shared/useDoctypeMeta";
+export type { DocFieldMeta, DocLinkMeta, DocPermissionRule, DoctypeMeta, DoctypeMetaBundle, } from "./shared/useDoctypeMeta";
+export { invalidateDocinfo, useDocinfo } from "./shared/useDocinfo";
+export type { DocInfo, DocInfoComment } from "./shared/useDocinfo";
+export { useSlugTarget } from "./shared/useSlugTarget";
+export { useUserRoles } from "./shared/useUserRoles";
+export { useRecentVisit } from "./shared/useRecentVisit";
+export type { RecentVisit } from "./shared/useRecentVisit";
+export { useSessionUserId } from "./shared/useSessionUserId";
+export type { FrappeFilterTuple, WorkspaceBlock, WorkspaceBlockType, WorkspaceChartRow, WorkspaceLinkGroup, WorkspaceLinkRow, WorkspaceNumberCardRow, WorkspaceDoc as WorkspacePageDoc, WorkspaceQuickListRow, WorkspaceShortcutRow, } from "./workspace/types";
+export { composeWorkspaceBlocks, findLinkGroup, findShortcut, groupLinks, headerLevel, parseFrappeFilters, parseWorkspaceContent, stripHtml, } from "./workspace/parseContent";
+export type { WorkspaceComposition } from "./workspace/parseContent";
+export { useFrappeDoc, useWorkspaceDoc } from "./workspace/useWorkspaceDoc";
+export type { UseFrappeDocResult } from "./workspace/useWorkspaceDoc";
+export { useDashboardChartData } from "./workspace/useDashboardChart";
+export type { DashboardChartDoc, DashboardChartSeries, UseDashboardChartDataResult, } from "./workspace/useDashboardChart";
+export { WorkspaceGrid } from "./workspace/WorkspaceGrid";
+export type { WorkspaceGridItem, WorkspaceGridProps } from "./workspace/WorkspaceGrid";
+export { WorkspaceLinkCard, resolveLinkTarget } from "./workspace/WorkspaceLinkCard";
+export type { WorkspaceLinkCardProps } from "./workspace/WorkspaceLinkCard";
+export { WorkspaceShortcut, resolveShortcutTarget } from "./workspace/WorkspaceShortcut";
+export type { WorkspaceShortcutProps } from "./workspace/WorkspaceShortcut";
+export { WorkspaceQuickList } from "./workspace/WorkspaceQuickList";
+export type { WorkspaceQuickListProps } from "./workspace/WorkspaceQuickList";
+export { WorkspaceNumberCard } from "./workspace/WorkspaceNumberCard";
+export type { NumberCardDoc, WorkspaceNumberCardProps } from "./workspace/WorkspaceNumberCard";
+export { WorkspaceChartBlock } from "./workspace/WorkspaceChartBlock";
+export type { WorkspaceChartBlockProps } from "./workspace/WorkspaceChartBlock";
+export { WorkspaceLinkDirectory, filterLinkGroup } from "./workspace/WorkspaceLinkDirectory";
+export type { WorkspaceLinkDirectoryItem, WorkspaceLinkDirectoryProps, } from "./workspace/WorkspaceLinkDirectory";
+export { WorkspaceRecents } from "./workspace/WorkspaceRecents";
+export { WorkspaceScreen } from "./workspace/WorkspaceScreen";
+export type { WorkspaceBlockKind, WorkspaceScreenProps } from "./workspace/WorkspaceScreen";
 //# sourceMappingURL=index.d.ts.map