Skip to content

Build your personal knowledge base with Trilium Notes

Merge remote-tracking branch 'origin/main' into pr-11877

Elian Dorana5e8ce83136f
diff --cc apps/client/src/services/content_renderer.spec.ts
index ea1631bbc5,9da9c30f17..0d4474dc5b
--- a/apps/client/src/services/content_renderer.spec.ts
+++ b/apps/client/src/services/content_renderer.spec.ts
@@@ -587,6 -901,12 +901,12 @@@ describe("getRenderedContent render / d
expect($renderedContent.find(".render-ok").length).toBe(1);
});
+ it("mounts a JSX render note under the given parent component", async () => {
+ const parentComponent = new Component();
+ await getRenderedContent(buildNote({ title: "R", type: "render" }), { parentComponent });
- expect(renderServiceRender.mock.lastCall?.[3]).toBe(parentComponent);
++ expect(renderServiceRender.mock.lastCall?.[3]).toEqual({ parentComponent });
+ });
+
it("render error callback shows an admonition with the error message", async () => {
renderServiceRender.mockImplementationOnce(async (_n: any, $content: any, onError: any) => {
onError(new Error("kaput"));
diff --cc apps/client/src/services/content_renderer.ts
index 0bbea011b6,a4951eb08f..ee4cea3e43
--- a/apps/client/src/services/content_renderer.ts
+++ b/apps/client/src/services/content_renderer.ts
@@@ -156,11 -230,10 +230,10 @@@ export async function getRenderedConten
} else if (type === "render" && entity instanceof FNote) {
const $content = $("<div>");
+ const { default: renderService } = await CONTENT_RENDERERS.render();
await renderService.render(entity, $content, (e, noteId) => {
showRenderError($content, e, noteId).catch((cardError) => console.error("Failed to render the script error card:", cardError));
- });
- }, options.parentComponent);
++ }, { parentComponent: options.parentComponent });
$renderedContent.append($content);
} else if (type === "doc" && "noteId" in entity) {
diff --cc apps/client/src/services/render.spec.tsx
index c4e3e98cbd,dc75e89110..0249338d0c
--- a/apps/client/src/services/render.spec.tsx
+++ b/apps/client/src/services/render.spec.tsx
@@@ -265,23 -263,32 +266,58 @@@ describe("render", () =>
expect(renderAtElementMock.mock.calls[0][2]).toBe($el[0]);
});
- it("does not mount a script modal after its render note was cancelled", async () => {
- const target = buildNote({ title: "Target", type: "code" });
- target.mime = "text/jsx";
- const note = buildNote({ title: "Host", "~renderNote": target.noteId });
- let finishExecution: ((value: unknown) => void) | undefined;
- executeMock.mockReturnValue(new Promise(resolve => { finishExecution = resolve; }));
++ it("mounts nothing once its signal is aborted", async () => {
++ const target = buildNote({ title: "Target9", type: "code" });
++ const jsxNote = buildNote({ id: "jsxRoot9", title: "JSX root" });
++ jsxNote.mime = "text/jsx";
++ const note = buildNote({ title: "Host9", "~renderNote": target.noteId });
++ server.postWithSilentInternalServerError = vi.fn(async () => ({
++ script: "",
++ html: "",
++ noteId: "jsxRoot9",
++ allNoteIds: []
++ })) as typeof server.postWithSilentInternalServerError;
++ let finishScript: (result: unknown) => void = () => {};
++ executeMock.mockReturnValue(new Promise((resolve) => { finishScript = resolve; }));
++ (glob as any).getComponentByEl = vi.fn(() => ({ fake: "component" }));
+ const controller = new AbortController();
- const $el = $("<div class='component'>");
- Object.assign(glob, { getComponentByEl: vi.fn(() => ({ fake: "component" })) });
+
- await render(note, $el, vi.fn(), controller.signal);
++ const $el = $("<div class='component'>");
++ await render(note, $el, vi.fn(), { signal: controller.signal });
++ expect(executeMock).toHaveBeenCalledOnce();
+ controller.abort();
- finishExecution?.(() => null);
- await flush();
++ finishScript(() => null);
++ await waitForPendingRenders($el[0]);
+
+ expect(renderAtElementMock).not.toHaveBeenCalled();
+ });
++
+ it("holds waitForPendingRenders until the script and its JSX mount have settled", async () => {
+ const target = buildNote({ title: "Target8", type: "code" });
+ const jsxNote = buildNote({ id: "jsxRoot8", title: "JSX root" });
+ jsxNote.mime = "text/jsx";
+ const note = buildNote({ title: "Host8", "~renderNote": target.noteId });
+ server.postWithSilentInternalServerError = vi.fn(async () => ({
+ script: "",
+ html: "",
+ noteId: "jsxRoot8",
+ allNoteIds: []
+ })) as typeof server.postWithSilentInternalServerError;
+ let finishScript: (result: unknown) => void = () => {};
+ executeMock.mockReturnValue(new Promise((resolve) => { finishScript = resolve; }));
+ (glob as any).getComponentByEl = vi.fn(() => ({ fake: "component" }));
+
+ const $el = $("<div class='component'>");
+ await render(note, $el, vi.fn());
+ let settled = false;
+ const wait = waitForPendingRenders($el[0]).then(() => { settled = true; });
+ await flush();
+ expect(settled).toBe(false);
+
+ finishScript(() => null);
+ await wait;
+ expect(renderAtElementMock).toHaveBeenCalledOnce();
+ });
});
describe("renderIfJsx", () => {
diff --cc apps/client/src/services/render.tsx
index 73dbbd9102,2a097445e2..3d96684b2f
--- a/apps/client/src/services/render.tsx
+++ b/apps/client/src/services/render.tsx
@@@ -1,30 -1,34 +1,43 @@@
import { Component, h, VNode } from "preact";
+ import type AppComponent from "../components/component.js";
+
import type FNote from "../entities/fnote.js";
-import { renderReactWidgetAtElement } from "../widgets/react/react_utils.jsx";
+import { disposeReactWidget, renderReactWidgetAtElement } from "../widgets/react/react_utils.jsx";
import { type Bundle, executeBundleWithoutErrorHandling } from "./bundle.js";
import froca from "./froca.js";
+ import { trackPendingRender } from "./pending_renders.js";
import { keepStylesScoped, RENDER_SCOPE_CLASS } from "./render_css_scope.js";
- import server from "./server.js";
/**
* @param noteId the render note the error is attributed to, so the caller can link back to it.
*/
type ErrorHandler = (e: unknown, noteId?: string) => void;
- export async function render(note: FNote, $el: JQuery<HTMLElement>, onError?: ErrorHandler, signal?: AbortSignal) {
-/**
- * @param parentComponent the component a JSX render note's element is mounted under, by default the
- * one of the closest `.component` element.
- */
-export async function render(note: FNote, $el: JQuery<HTMLElement>, onError?: ErrorHandler, parentComponent?: AppComponent) {
++interface RenderOptions {
++ /** The component a JSX render note's element mounts under; by default the closest `.component` element's. */
++ parentComponent?: AppComponent;
++ /** Once aborted, the render mounts nothing and reports no errors, so a stale render cannot leave a portal behind. */
++ signal?: AbortSignal;
++}
++
++export async function render(note: FNote, $el: JQuery<HTMLElement>, onError?: ErrorHandler, options: RenderOptions = {}) {
++ const { signal } = options;
const relations = note.getRelations("renderNote");
const renderNoteIds = relations.map((rel) => rel.value).filter((noteId) => noteId);
++ const reportError: ErrorHandler = (e, noteId) => {
++ if (!signal?.aborted) onError?.(e, noteId);
++ };
+ disposeReactWidget($el[0]);
$el.empty().toggle(renderNoteIds.length > 0);
let currentRenderNoteId: string | undefined;
try {
for (const renderNoteId of renderNoteIds) {
currentRenderNoteId = renderNoteId;
- const bundle = await server.postWithSilentInternalServerError<Bundle>(`script/bundle/${renderNoteId}`);
+ const bundle = await froca.getScriptBundle(renderNoteId);
+ if (signal?.aborted) return;
if (!bundle) {
throw new Error(`Script note '${renderNoteId}' could not be loaded. It may be protected and require an active protected session.`);
@@@ -36,37 -40,35 +49,36 @@@
$scriptContainer.append(bundle.html);
keepStylesScoped($scriptContainer[0]);
- // async so that scripts cannot block trilium execution
- void executeBundleWithoutErrorHandling(bundle, note, $scriptContainer)
- .catch((e) => { if (!signal?.aborted) onError?.(e, renderNoteId); })
- .then(result => {
- if (signal?.aborted) return;
- // Render JSX
+ // Not awaited, so that a script cannot block Trilium. `trackPendingRender` lets printing
+ // wait for the script and its JSX mount before it captures the page.
+ const work = executeBundleWithoutErrorHandling(bundle, note, $scriptContainer)
- .catch((e) => onError?.(e, renderNoteId))
++ .catch((e) => reportError(e, renderNoteId))
+ .then(async (result) => {
if (bundle.html === "") {
- renderIfJsx(bundle, result, $el, onError, signal).catch((e) => { if (!signal?.aborted) onError?.(e, bundle.noteId); });
- await renderIfJsx(bundle, result, $el, onError, parentComponent).catch((e) => onError?.(e, bundle.noteId));
++ await renderIfJsx(bundle, result, $el, reportError, options).catch((e) => reportError(e, bundle.noteId));
}
});
+ trackPendingRender($el[0], work);
}
return renderNoteIds.length > 0;
} catch (e) {
- if (signal?.aborted) return;
if (typeof e === "string" && e.startsWith("{") && e.endsWith("}")) {
try {
-- onError?.(JSON.parse(e), currentRenderNoteId);
++ reportError(JSON.parse(e), currentRenderNoteId);
} catch (e) {
-- onError?.(e, currentRenderNoteId);
++ reportError(e, currentRenderNoteId);
}
} else {
-- onError?.(e, currentRenderNoteId);
++ reportError(e, currentRenderNoteId);
}
}
}
- export async function renderIfJsx(bundle: Bundle, result: unknown, $el: JQuery<HTMLElement>, onError?: ErrorHandler, signal?: AbortSignal) {
-export async function renderIfJsx(bundle: Bundle, result: unknown, $el: JQuery<HTMLElement>, onError?: ErrorHandler, parentComponent?: AppComponent) {
++export async function renderIfJsx(bundle: Bundle, result: unknown, $el: JQuery<HTMLElement>, onError?: ErrorHandler, { parentComponent, signal }: RenderOptions = {}) {
// Ensure the root script note is actually a JSX.
const rootScriptNoteId = await froca.getNote(bundle.noteId);
+ if (signal?.aborted) return;
if (rootScriptNoteId?.mime !== "text/jsx") return;
// Ensure the output is a valid el.
diff --cc apps/client/src/widgets/type_widgets/Render.spec.tsx
index 9f8e2fb4d6,0000000000..3d9898a641
mode 100644,000000..100644
--- a/apps/client/src/widgets/type_widgets/Render.spec.tsx
+++ b/apps/client/src/widgets/type_widgets/Render.spec.tsx
@@@ -1,54 -1,0 +1,55 @@@
+import { render } from "preact";
+import { act } from "preact/test-utils";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const renderNote = vi.hoisted(() => vi.fn());
+
+vi.mock("../../services/render", () => ({ default: { render: renderNote } }));
+vi.mock("../react/hooks", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("../react/hooks")>()),
+ useNoteRelation: (_note: unknown, name: string) => name === "renderNote" ? [ {} ] : [],
- useTriliumEvent: () => {}
++ useTriliumEvent: () => {},
++ useEffectiveReadOnly: () => false
+}));
+
+import type FNote from "../../entities/fnote";
+import * as reactUtils from "../react/react_utils";
+import Render from "./Render";
+import type { TypeWidgetProps } from "./type_widget";
+
+const container = document.createElement("div");
+document.body.appendChild(container);
+
+afterEach(async () => {
+ await act(async () => render(null, container));
+ renderNote.mockClear();
+});
+
+describe("Render content", () => {
+ it("aborts the previous render on note change and on unmount", async () => {
+ const dispose = vi.spyOn(reactUtils, "disposeReactWidget");
+ const first = { noteId: "first" } as FNote;
+ const second = { noteId: "second" } as FNote;
+ const props = (note: FNote) => ({ note, ntxId: "pane", noteContext: null }) as unknown as TypeWidgetProps;
+
+ await act(async () => render(<Render {...props(first)} />, container));
+ expect(renderNote).toHaveBeenCalledTimes(1);
+ expect(renderNote.mock.calls[0][0]).toBe(first);
+ const firstContainer = container.querySelector(".note-detail-render-content");
- const firstSignal = renderNote.mock.calls[0][3] as AbortSignal;
++ const firstSignal = (renderNote.mock.calls[0][3] as { signal: AbortSignal }).signal;
+ expect(firstSignal.aborted).toBe(false);
+
+ await act(async () => render(<Render {...props(second)} />, container));
+ expect(firstSignal.aborted).toBe(true);
+ expect(dispose).toHaveBeenCalledWith(firstContainer);
+ expect(renderNote).toHaveBeenCalledTimes(2);
+ const secondContainer = container.querySelector(".note-detail-render-content");
- const secondSignal = renderNote.mock.calls[1][3] as AbortSignal;
++ const secondSignal = (renderNote.mock.calls[1][3] as { signal: AbortSignal }).signal;
+ expect(secondSignal.aborted).toBe(false);
+
+ await act(async () => render(null, container));
+ expect(secondSignal.aborted).toBe(true);
+ expect(dispose).toHaveBeenCalledWith(secondContainer);
+ dispose.mockRestore();
+ });
+});
diff --cc apps/client/src/widgets/type_widgets/Render.tsx
index 217b9d53a4,8aa49b33a9..2375c631d7
--- a/apps/client/src/widgets/type_widgets/Render.tsx
+++ b/apps/client/src/widgets/type_widgets/Render.tsx
@@@ -11,9 -11,10 +11,10 @@@ import toast from "../../services/toast
import Button, { SplitButton } from "../react/Button";
import FormGroup from "../react/FormGroup";
import { FormListItem } from "../react/FormList";
- import { useNoteRelation, useTriliumEvent } from "../react/hooks";
+ import { useEffectiveReadOnly, useNoteRelation, useTriliumEvent } from "../react/hooks";
+ import NoItems from "../react/NoItems";
import NoteAutocomplete from "../react/NoteAutocomplete";
- import { disposeReactWidget, refToJQuerySelector } from "../react/react_utils";
-import { ParentComponent, refToJQuerySelector } from "../react/react_utils";
++import { disposeReactWidget, ParentComponent, refToJQuerySelector } from "../react/react_utils";
import RenderErrorCard from "../react/RenderErrorCard";
import SetupForm from "./helpers/SetupForm";
import { TypeWidgetProps } from "./type_widget";
@@@ -48,30 -55,20 +55,34 @@@ export default function Render(props: T
function RenderContent({ note, noteContext, ntxId }: TypeWidgetProps) {
const contentRef = useRef<HTMLDivElement>(null);
+ const renderController = useRef<AbortController | null>(null);
const [ error, setError ] = useState<{ error: unknown; noteId?: string } | null>(null);
+ const parentComponent = useContext(ParentComponent);
- const refresh = useCallback(() => {
+ function refresh() {
- if (!contentRef) return;
+ if (!contentRef.current) return;
+ renderController.current?.abort();
+ const controller = new AbortController();
+ renderController.current = controller;
setError(null);
- void render.render(note, refToJQuerySelector(contentRef), (e, noteId) => setError({ error: e, noteId }), controller.signal);
- }, [ note ]);
- render.render(note, refToJQuerySelector(contentRef), (e, noteId) => setError({ error: e, noteId }), parentComponent ?? undefined);
++ void render.render(note, refToJQuerySelector(contentRef), (e, noteId) => setError({ error: e, noteId }), {
++ parentComponent: parentComponent ?? undefined,
++ signal: controller.signal
++ });
+ }
- useEffect(refresh, [ note ]);
+ useEffect(() => {
+ refresh();
+ const container = contentRef.current;
+ return () => {
+ renderController.current?.abort();
+ if (container) disposeReactWidget(container);
+ };
- }, [ refresh ]);
++ }, [ note ]);
// Keyboard shortcut.
- useTriliumEvent("renderActiveNote", () => {
- if (!noteContext?.isActive()) return;
+ useTriliumEvent("renderActiveNote", ({ ntxId: eventNtxId }) => {
+ if (!noteContext?.isCommandTarget(eventNtxId)) return;
refresh();
});