@multiplatform.one/frappe-ui 7.83.0 → 7.83.2

package/src/FrappeReportBuilder.export.spec.tsx

@@ -0,0 +1,143 @@
+// FZ-8893: the built-in Export CSV saves through @multiplatform.one/platform/file,
+// so native gets the directory picker instead of a dead download, and the toast
+// says what happened: written, download requested, nothing on cancel, or the
+// FileSaveError.
+import { notify } from "@multiplatform.one/components";
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { FileSaveError, saveFile } from "@multiplatform.one/platform/file";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { cleanup, fireEvent, screen, waitFor } from "@testing-library/react";
+import i18next from "i18next";
+import React from "react";
+import { initReactI18next } from "react-i18next";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import { FrappeProvider } from "./FrappeProvider";
+import { FrappeReportBuilder } from "./FrappeReportBuilder";
+
+vi.mock("@multiplatform.one/components", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@multiplatform.one/components")>()),
+  notify: vi.fn(),
+}));
+vi.mock("@multiplatform.one/platform/file", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@multiplatform.one/platform/file")>()),
+  saveFile: vi.fn(),
+}));
+
+const save = vi.mocked(saveFile);
+const toast = vi.mocked(notify);
+
+beforeAll(async () => {
+  await i18next.use(initReactI18next).init({
+    lng: "en",
+    interpolation: { escapeValue: false },
+    resources: { en: { translation: {} } },
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  save.mockReset();
+  toast.mockReset();
+});
+
+const customers = [
+  { name: "CUST-001", doctype: "Customer", customer_name: "Acme Corp" },
+  { name: "CUST-002", doctype: "Customer", customer_name: "Globex, Inc" },
+];
+
+let run = 0;
+function renderBuilder() {
+  run += 1;
+  renderWithProviders(
+    <FrappeProvider
+      baseURL={`https://report-export-${run}.spec.test`}
+      fixtures={
+        new InMemoryFixtureProvider({
+          DocType: [
+            {
+              name: "Customer",
+              doctype: "DocType",
+              module: "Selling",
+              title_field: "customer_name",
+              fields: [
+                {
+                  fieldname: "customer_name",
+                  fieldtype: "Data",
+                  label: "Customer Name",
+                  in_list_view: 1,
+                },
+              ],
+            },
+          ],
+          Customer: customers,
+        })
+      }
+    >
+      <FrappeReportBuilder doctype="Customer" />
+    </FrappeProvider>,
+  );
+}
+
+async function exportCsv() {
+  await screen.findByText("Acme Corp");
+  fireEvent.click(screen.getByRole("button", { name: "Export CSV" }));
+  await waitFor(() => expect(save).toHaveBeenCalledTimes(1));
+}
+
+function toasts(severity: string) {
+  return toast.mock.calls.map(([event]) => event).filter((event) => event.severity === severity);
+}
+
+describe("FrappeReportBuilder Export CSV (FZ-8893)", () => {
+  it("saves the filtered result's CSV bytes as text/csv", async () => {
+    save.mockResolvedValue({ status: "download-requested" });
+    renderBuilder();
+    await exportCsv();
+    const [options] = save.mock.calls[0];
+    expect(options.filename).toBe("Customer_report.csv");
+    expect(options.mimeType).toBe("text/csv;charset=utf-8;");
+    const text = new TextDecoder().decode(options.bytes);
+    expect(text).toContain("Acme Corp");
+    expect(text).toContain('"Globex, Inc"');
+  });
+
+  it("a requested download is the export-done toast", async () => {
+    save.mockResolvedValue({ status: "download-requested" });
+    renderBuilder();
+    await exportCsv();
+    await waitFor(() => expect(toasts("success")).toHaveLength(1));
+    expect(String(toasts("success")[0].body)).toMatch(/Exported 2 rows to CSV/);
+  });
+
+  it("a written file is a success toast naming the file", async () => {
+    save.mockResolvedValue({
+      status: "written",
+      uri: "file:///docs/Customer_report.csv",
+      requestedFilename: "Customer_report.csv",
+      filename: "Customer_report.csv",
+      byteLength: 40,
+    });
+    renderBuilder();
+    await exportCsv();
+    await waitFor(() => expect(toasts("success")).toHaveLength(1));
+    expect(String(toasts("success")[0].body)).toMatch(/Saved 2 rows to Customer_report\.csv/);
+  });
+
+  it("a cancelled picker shows no success toast", async () => {
+    save.mockResolvedValue({ status: "not-saved", reason: "cancelled-or-refused" });
+    renderBuilder();
+    await exportCsv();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(toasts("success")).toHaveLength(0);
+    expect(toasts("error")).toHaveLength(0);
+  });
+
+  it("a FileSaveError is an error toast", async () => {
+    save.mockRejectedValue(new FileSaveError("picker-failed", "No writable folder was chosen."));
+    renderBuilder();
+    await exportCsv();
+    await waitFor(() => expect(toasts("error")).toHaveLength(1));
+    expect(toasts("error")[0].body).toBe("No writable folder was chosen.");
+    expect(toasts("success")).toHaveLength(0);
+  });
+});

package/src/FrappeReportBuilder.tsx

@@ -39,7 +39,6 @@ import {
   type FrappeFieldType,
 } from "@multiplatform.one/frappe";
 import { Button } from "@multiplatform.one/forms";
-import { downloadBlob } from "@multiplatform.one/platform";
 import { storage } from "@multiplatform.one/store";
 import { DataTablePagination } from "@multiplatform.one/table";
 import { useLayoutSizeClass, useResolvedKnobs } from "@multiplatform.one/theme";
@@ -50,6 +49,7 @@ import { FrappeNotConfigured } from "./FrappeNotConfigured";
 import { useFrappeConfig } from "./FrappeProvider";
 import { isPermissionError, refusalReason } from "./liveErrors";
 import { recordKeyLabel, useRecordShape } from "./recordShape";
+import { canSaveCsv, exportCsvFile } from "./report/exportCsv";
 import { ReportGrid } from "./report/ReportGrid";
 import { ReportViewToolbar } from "./report/ReportViewToolbar";
 import {
@@ -237,21 +237,6 @@ function aggregateGroups(
   });
 }
 
-/**
- * The export button needs somewhere to put a file: a DOM anchor and an
- * object URL. Native and GTK have neither, so the built-in CSV path is left
- * out there (B12); a host `onExport` owns delivery and shows everywhere.
- */
-function canDownloadCsv(): boolean {
-  return (
-    typeof document !== "undefined" &&
-    typeof document.createElement === "function" &&
-    typeof Blob !== "undefined" &&
-    typeof URL !== "undefined" &&
-    typeof URL.createObjectURL === "function"
-  );
-}
-
 export function FrappeReportBuilder(props: FrappeReportBuilderProps) {
   const config = useFrappeConfig();
   if (!(props.baseURL ?? config?.baseURL) && !config?.fixtures) {
@@ -688,26 +673,17 @@ function FrappeReportBuilderBody({
   );
 
   // ── Export: full filtered + ordered result ──────────────────
-  const exportEnabled = Boolean(onExport) || canDownloadCsv();
+  const exportEnabled = Boolean(onExport) || canSaveCsv();
   const handleExport = useCallback(() => {
     if (onExport) {
       onExport(orderedRows);
       return;
     }
-    downloadBlob(
-      new Blob([buildReportCsv(selectedColumns, orderedRows)], {
-        type: "text/csv;charset=utf-8;",
-      }),
-      `${doctype}_report.csv`,
-    );
-    notify({
-      severity: "success",
-      scope: "page",
-      body: t("report.exportDone", {
-        count: orderedRows.length,
-        defaultValue_one: "Exported {{count}} row to CSV",
-        defaultValue_other: "Exported {{count}} rows to CSV",
-      }),
+    void exportCsvFile({
+      csv: buildReportCsv(selectedColumns, orderedRows),
+      filename: `${doctype}_report.csv`,
+      rowCount: orderedRows.length,
+      t,
     });
   }, [onExport, selectedColumns, orderedRows, doctype, t]);
 

package/src/formEngine/useSessionRoles.ts

@@ -11,6 +11,7 @@
  */
 
 import { useEffect, useRef, useState } from "react";
+import { loadSessionUser, sessionUserKey, useSessionRevision } from "../sessionUser";
 import { createHttpClient, type FrappeConnection } from "./formActions";
 
 interface SessionIdentity {
@@ -18,14 +19,12 @@ interface SessionIdentity {
   roles: string[];
 }
 
-const sessionCache = new Map<string, Promise<SessionIdentity>>();
+const sessionCache = new Map<string, Promise<SessionIdentity | null>>();
 
-function fetchSession(connection: FrappeConnection): Promise<SessionIdentity> {
-  const http = createHttpClient(connection);
-  return http.get<{ message?: string }>("/api/method/frappe.auth.get_logged_user").then((res) => {
-    const user = res.payload?.message;
-    if (!user || typeof user !== "string") throw new Error("No session user");
-    return http
+function fetchSession(connection: FrappeConnection): Promise<SessionIdentity | null> {
+  return loadSessionUser(connection).then((user) => {
+    if (user === "Guest") return null;
+    return createHttpClient(connection)
       .get<{ message?: string[] }>("/api/method/frappe.core.doctype.user.user.get_roles", {
         uid: user,
       })
@@ -64,6 +63,9 @@ export function useFrappeSession(connection: SessionConnection | undefined): Fra
   const connectionRef = useRef(connection);
   connectionRef.current = connection;
 
+  const authKey = connection ? sessionUserKey(connection) : "";
+  const revision = useSessionRevision();
+
   useEffect(() => {
     const current = connectionRef.current;
     if (!current || fixtures || !baseURL) {
@@ -72,15 +74,20 @@ export function useFrappeSession(connection: SessionConnection | undefined): Fra
     }
     let cancelled = false;
     setSession((prev) => (prev.state === "loading" ? prev : { state: "loading" }));
-    let promise = sessionCache.get(baseURL);
+    const key = `${authKey}#${revision}`;
+    let promise = sessionCache.get(key);
     if (!promise) {
-      promise = fetchSession({ ...current, baseURL });
-      sessionCache.set(baseURL, promise);
-      promise.catch(() => sessionCache.delete(baseURL));
+      const pending = fetchSession({ ...current, baseURL });
+      promise = pending;
+      sessionCache.set(key, pending);
+      pending.catch(() => {
+        if (sessionCache.get(key) === pending) sessionCache.delete(key);
+      });
     }
     promise
-      .then(({ user, roles }) => {
-        if (!cancelled) setSession({ user, roles, state: "ready" });
+      .then((identity) => {
+        if (cancelled) return;
+        setSession(identity ? { ...identity, state: "ready" } : { state: "failed" });
       })
       .catch(() => {
         if (!cancelled) setSession({ state: "failed" });
@@ -88,7 +95,7 @@ export function useFrappeSession(connection: SessionConnection | undefined): Fra
     return () => {
       cancelled = true;
     };
-  }, [baseURL, fixtures]);
+  }, [baseURL, fixtures, authKey, revision]);
 
   if (!active) return idleSession;
   return session.state === "idle" ? loadingSession : session;

package/src/index.ts

@@ -543,6 +543,12 @@ export {
   type UseQueryReportOptions,
   type UseQueryReportResult,
 } from "./report/useQueryReport";
+export {
+  canSaveCsv,
+  CSV_MIME_TYPE,
+  exportCsvFile,
+  type ExportCsvFileOptions,
+} from "./report/exportCsv";
 export {
   buildQueryReportColumns,
   buildQueryReportCsv,
@@ -658,6 +664,14 @@ export type {
   ResolveDocRightsInput,
   SessionDocRightsInput,
 } from "./formEngine";
+export {
+  clearSessionIdentityCache,
+  getSessionRevision,
+  loadSessionUser,
+  sessionUserKey,
+  useSessionRevision,
+  type SessionUserSource,
+} from "./sessionUser";
 export { connectionFields, connectionsFromMeta, type FrappeConnection } from "./frappeConnections";
 
 // ---------------------------------------------------------------------------

package/src/report/exportCsv.spec.ts

@@ -0,0 +1,118 @@
+import { notify } from "@multiplatform.one/components";
+import { FileSaveError, saveFile } from "@multiplatform.one/platform/file";
+import type { TFunction } from "i18next";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { CSV_MIME_TYPE, canSaveCsv, exportCsvFile } from "./exportCsv";
+
+vi.mock("@multiplatform.one/components", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@multiplatform.one/components")>()),
+  notify: vi.fn(),
+}));
+vi.mock("@multiplatform.one/platform/file", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@multiplatform.one/platform/file")>()),
+  saveFile: vi.fn(),
+}));
+const native = vi.hoisted(() => ({ ios: false }));
+vi.mock("@multiplatform.one/platform", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@multiplatform.one/platform")>();
+  return {
+    ...actual,
+    get isIos() {
+      return native.ios;
+    },
+  };
+});
+
+const t = ((key: string, options?: unknown) =>
+  typeof options === "string"
+    ? `${key}|${options}`
+    : `${key}|${JSON.stringify(options)}`) as TFunction;
+const save = vi.mocked(saveFile);
+const toast = vi.mocked(notify);
+const csv = 'Name,Café\nA-1,"a, b"';
+
+afterEach(() => {
+  save.mockReset();
+  toast.mockReset();
+  native.ios = false;
+  vi.unstubAllGlobals();
+});
+
+describe("exportCsvFile (FZ-8893)", () => {
+  it("hands saveFile the CSV's UTF-8 bytes, its filename and the CSV type", async () => {
+    save.mockResolvedValue({ status: "download-requested" });
+    await exportCsvFile({ csv, filename: "Customer_report.csv", rowCount: 1, t });
+    const [options] = save.mock.calls[0];
+    expect(options.filename).toBe("Customer_report.csv");
+    expect(options.mimeType).toBe(CSV_MIME_TYPE);
+    expect(Array.from(options.bytes)).toEqual(Array.from(new TextEncoder().encode(csv)));
+  });
+
+  it("a written file is a success toast naming the file", async () => {
+    save.mockResolvedValue({
+      status: "written",
+      uri: "file:///docs/Customer_report%202.csv",
+      requestedFilename: "Customer_report.csv",
+      filename: "Customer_report 2.csv",
+      byteLength: 20,
+    });
+    const result = await exportCsvFile({ csv, filename: "Customer_report.csv", rowCount: 3, t });
+    expect(result?.status).toBe("written");
+    expect(toast).toHaveBeenCalledTimes(1);
+    expect(toast.mock.calls[0][0]).toMatchObject({ severity: "success" });
+    expect(String(toast.mock.calls[0][0].body)).toContain("report.exportSaved");
+    expect(String(toast.mock.calls[0][0].body)).toContain("Customer_report 2.csv");
+  });
+
+  it("a requested download is the export-done toast", async () => {
+    save.mockResolvedValue({ status: "download-requested" });
+    await exportCsvFile({ csv, filename: "x.csv", rowCount: 2, t });
+    expect(toast).toHaveBeenCalledTimes(1);
+    expect(toast.mock.calls[0][0]).toMatchObject({ severity: "success" });
+    expect(String(toast.mock.calls[0][0].body)).toContain("report.exportDone");
+  });
+
+  it("a cancelled picker says nothing", async () => {
+    save.mockResolvedValue({ status: "not-saved", reason: "cancelled-or-refused" });
+    const result = await exportCsvFile({ csv, filename: "x.csv", rowCount: 2, t });
+    expect(result).toEqual({ status: "not-saved", reason: "cancelled-or-refused" });
+    expect(toast).not.toHaveBeenCalled();
+  });
+
+  it("a FileSaveError is an error toast with its message", async () => {
+    save.mockRejectedValue(new FileSaveError("write-failed", "The file could not be written."));
+    const result = await exportCsvFile({ csv, filename: "x.csv", rowCount: 2, t });
+    expect(result).toBeUndefined();
+    expect(toast).toHaveBeenCalledTimes(1);
+    expect(toast.mock.calls[0][0]).toMatchObject({
+      severity: "error",
+      body: "The file could not be written.",
+    });
+  });
+
+  it("any other failure is the generic error toast", async () => {
+    save.mockRejectedValue(new Error("boom"));
+    await exportCsvFile({ csv, filename: "x.csv", rowCount: 2, t });
+    expect(toast.mock.calls[0][0]).toMatchObject({
+      severity: "error",
+      body: "report.exportFailed|CSV export failed",
+    });
+  });
+});
+
+describe("canSaveCsv (FZ-8893)", () => {
+  it("is true on web with a DOM download", () => {
+    expect(canSaveCsv()).toBe(true);
+  });
+
+  it("is false with neither a DOM nor a native picker (GTK)", () => {
+    vi.stubGlobal("document", undefined);
+    expect(canSaveCsv()).toBe(false);
+  });
+
+  it("is true on iOS, where there is no DOM download", () => {
+    vi.stubGlobal("document", undefined);
+    native.ios = true;
+    expect(canSaveCsv()).toBe(true);
+  });
+});

package/src/report/exportCsv.ts

@@ -0,0 +1,84 @@
+import { notify } from "@multiplatform.one/components";
+import { isAndroid, isIos } from "@multiplatform.one/platform";
+import { FileSaveError, saveFile, type FileSaveResult } from "@multiplatform.one/platform/file";
+import type { TFunction } from "i18next";
+
+/** The Blob type web CSV exports have always carried. */
+export const CSV_MIME_TYPE = "text/csv;charset=utf-8;";
+
+/**
+ * Whether this platform can put a CSV somewhere: the native directory picker
+ * on iOS and Android, a DOM download on web. GTK has neither.
+ */
+export function canSaveCsv(): boolean {
+  if (isIos || isAndroid) return true;
+  return (
+    typeof document !== "undefined" &&
+    typeof document.createElement === "function" &&
+    typeof Blob !== "undefined" &&
+    typeof URL !== "undefined" &&
+    typeof URL.createObjectURL === "function"
+  );
+}
+
+export interface ExportCsvFileOptions {
+  csv: string;
+  filename: string;
+  rowCount: number;
+  /** The caller's translator; keys live under `report.*` in its namespace. */
+  t: TFunction;
+}
+
+/**
+ * Saves a CSV through `@multiplatform.one/platform/file` and says what
+ * happened: a written file or a requested download is a success toast, a
+ * cancelled picker says nothing, a `FileSaveError` is an error toast.
+ */
+export async function exportCsvFile({
+  csv,
+  filename,
+  rowCount,
+  t,
+}: ExportCsvFileOptions): Promise<FileSaveResult | undefined> {
+  let result: FileSaveResult;
+  try {
+    result = await saveFile({
+      bytes: new TextEncoder().encode(csv),
+      filename,
+      mimeType: CSV_MIME_TYPE,
+    });
+  } catch (error) {
+    notify({
+      severity: "error",
+      scope: "page",
+      body:
+        error instanceof FileSaveError
+          ? error.message
+          : t("report.exportFailed", "CSV export failed"),
+    });
+    return undefined;
+  }
+  if (result.status === "written") {
+    notify({
+      severity: "success",
+      scope: "page",
+      body: t("report.exportSaved", {
+        count: rowCount,
+        filename: result.filename ?? result.requestedFilename,
+        defaultValue_one: "Saved {{count}} row to {{filename}}",
+        defaultValue_other: "Saved {{count}} rows to {{filename}}",
+      }),
+    });
+  } else if (result.status === "download-requested") {
+    notify({
+      severity: "success",
+      scope: "page",
+      body: t("report.exportDone", {
+        count: rowCount,
+        defaultValue_one: "Exported {{count}} row to CSV",
+        defaultValue_other: "Exported {{count}} rows to CSV",
+      }),
+    });
+  }
+  return result;
+}

package/src/sessionUser.spec.tsx

@@ -0,0 +1,84 @@
+// @vitest-environment happy-dom
+import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useFrappeSession } from "./formEngine/useSessionRoles";
+import { FrappeProvider, useFrappeConfig } from "./FrappeProvider";
+import { clearSessionIdentityCache, loadSessionUser } from "./sessionUser";
+
+let run = 0;
+let status = 403;
+const calls = { user: 0, roles: 0 };
+
+function Consumer({ id }: { id: string }) {
+  const session = useFrappeSession(useFrappeConfig());
+  return <span data-testid={id}>{session.state}</span>;
+}
+
+function Tree() {
+  return (
+    <FrappeProvider baseURL={`https://session-${run}.spec.test`} realtime={false}>
+      <Consumer id="a" />
+      <Consumer id="b" />
+      <Consumer id="c" />
+    </FrappeProvider>
+  );
+}
+
+async function settled(state: string) {
+  await waitFor(() => {
+    for (const id of ["a", "b", "c"]) expect(screen.getByTestId(id).textContent).toBe(state);
+  });
+}
+
+beforeEach(() => {
+  run += 1;
+  status = 403;
+  calls.user = 0;
+  calls.roles = 0;
+  vi.stubGlobal("fetch", async (input: string | URL | Request) => {
+    const url = new URL(String(input instanceof Request ? input.url : input));
+    if (url.pathname.endsWith("frappe.auth.get_logged_user")) {
+      calls.user += 1;
+      return Response.json(status === 200 ? { message: "reader@example.test" } : {}, { status });
+    }
+    if (url.pathname.endsWith("frappe.core.doctype.user.user.get_roles")) {
+      calls.roles += 1;
+      return Response.json({ message: ["Reader"] });
+    }
+    return Response.json({});
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+
+it("asks a guest's bench who is signed in once, across consumers and remounts", async () => {
+  const view = render(<Tree />);
+  await settled("failed");
+  await loadSessionUser({ baseURL: `https://session-${run}.spec.test` });
+  view.unmount();
+  render(<Tree />);
+  await settled("failed");
+  expect(calls).toEqual({ user: 1, roles: 0 });
+});
+
+it("reads a signed-in user and their roles once", async () => {
+  status = 200;
+  const view = render(<Tree />);
+  await settled("ready");
+  view.unmount();
+  render(<Tree />);
+  await settled("ready");
+  expect(calls).toEqual({ user: 1, roles: 1 });
+});
+
+it("asks again once the session identity is cleared", async () => {
+  render(<Tree />);
+  await settled("failed");
+  status = 200;
+  act(() => clearSessionIdentityCache());
+  await settled("ready");
+  expect(calls).toEqual({ user: 2, roles: 1 });
+});

package/src/sessionUser.ts

@@ -0,0 +1,65 @@
+import { HttpClient, type AuthConfig } from "@multiplatform.one/frappe";
+import { useSyncExternalStore } from "react";
+
+export interface SessionUserSource {
+  baseURL?: string;
+  auth?: {
+    useToken?: boolean;
+    token?: string | (() => string | Promise<string>);
+    type?: string;
+  };
+}
+
+const users = new Map<string, Promise<string>>();
+let revision = 0;
+const listeners = new Set<() => void>();
+
+function subscribe(listener: () => void) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function getRevision() {
+  return revision;
+}
+
+export function getSessionRevision(): number {
+  return revision;
+}
+
+export function useSessionRevision(): number {
+  return useSyncExternalStore(subscribe, getRevision, getRevision);
+}
+
+export function sessionUserKey(source: SessionUserSource): string {
+  const auth = source.auth;
+  return `${source.baseURL ?? ""}:${auth?.useToken ? "t" : ""}:${auth?.token ?? ""}:${auth?.type ?? ""}`;
+}
+
+export function clearSessionIdentityCache(): void {
+  users.clear();
+  revision += 1;
+  for (const listener of listeners) listener();
+}
+
+export function loadSessionUser(source: SessionUserSource): Promise<string> {
+  if (!source.baseURL) return Promise.reject(new Error("No session endpoint"));
+  const key = sessionUserKey(source);
+  let promise = users.get(key);
+  if (!promise) {
+    const client = new HttpClient(source.baseURL, source.auth as AuthConfig | undefined);
+    promise = client
+      .get<{ message?: string }>("/api/method/frappe.auth.get_logged_user")
+      .then((response) => response.payload?.message || "Guest")
+      .catch((error: unknown) => {
+        const status = (error as { status?: number })?.status;
+        if (status === 401 || status === 403) return "Guest";
+        if (users.get(key) === promise) users.delete(key);
+        throw error;
+      });
+    users.set(key, promise);
+  }
+  return promise;
+}

package/types/FrappeLikedBy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrappeLikedBy.d.ts","sourceRoot":"","sources":["../src/FrappeLikedBy.tsx"],"names":[],"mappings":"AAoBA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAY1F;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CAanD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAKlC;AAYD,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,MAAM,CAAC;IAChF,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACxD;AA8PD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAMtD"}
+{"version":3,"file":"FrappeLikedBy.d.ts","sourceRoot":"","sources":["../src/FrappeLikedBy.tsx"],"names":[],"mappings":"AAoBA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAa1F;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CAanD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAKlC;AAYD,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,MAAM,CAAC;IAChF,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACxD;AA6PD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAMtD"}