Skip to content

Build your personal knowledge base with Trilium Notes

feat(client): template properties dialog with the default title

Elian Doran48dc89a2614d
diff --git a/apps/client/src/components/app_context.ts b/apps/client/src/components/app_context.ts
index fb9197bda5..b0b7cf1dad 100644
--- a/apps/client/src/components/app_context.ts
+++ b/apps/client/src/components/app_context.ts
@@ -571,6 +571,8 @@ type EventMappings = {
};
/** Opens the properties dialog of a board or calendar, which only the view itself can show. */
showCollectionProperties: { ntxId: string | null | undefined; };
+ /** Opens the properties dialog of a template note. */
+ showTemplateProperties: { noteId: string; };
tabReorder: {
ntxIdsInOrder: string[];
};
diff --git a/apps/client/src/layouts/layout_commons.tsx b/apps/client/src/layouts/layout_commons.tsx
index d6be21df4d..b4b802cedc 100644
--- a/apps/client/src/layouts/layout_commons.tsx
+++ b/apps/client/src/layouts/layout_commons.tsx
@@ -18,6 +18,7 @@ export function applyModals(rootContainer: RootContainer) {
.child(<LazyDialog triggerEvents={["showRecentChanges", "showDeletedNotes"]} loader={() => import("../widgets/dialogs/recent_changes.js")} />)
.child(<LazyDialog triggerEvents={["editBranchPrefix"]} loader={() => import("../widgets/dialogs/branch_prefix.js")} />)
.child(<LazyDialog triggerEvents={["sortChildNotes"]} loader={() => import("../widgets/dialogs/sort_child_notes.js")} />)
+ .child(<LazyDialog triggerEvents={["showTemplateProperties"]} loader={() => import("../widgets/dialogs/template_properties.js")} />)
.child(<LazyDialog triggerEvents={["showContentEmbedDialog"]} loader={() => import("../widgets/dialogs/content_embed.js")} />)
.child(<LazyDialog triggerEvents={["showNotePickerDialog"]} loader={() => import("../widgets/dialogs/note_picker.js")} />)
.child(<LazyDialog triggerEvents={["chooseNoteType"]} loader={() => import("../widgets/dialogs/note_type_chooser.js")} />)
diff --git a/apps/client/src/translations/en/translation.json b/apps/client/src/translations/en/translation.json
index c58d6ecb17..8b945aedf1 100644
--- a/apps/client/src/translations/en/translation.json
+++ b/apps/client/src/translations/en/translation.json
@@ -3960,7 +3960,8 @@
"template_scope_global": "Available everywhere",
"template_scope_workspace": "Only inside its workspace",
"template_scope_workspace_unavailable": "The template is not inside a workspace.",
- "workspace_template": "Workspace template"
+ "workspace_template": "Workspace template",
+ "template_properties": "Template properties..."
},
"status_bar": {
"language_title": "Change content language",
@@ -4776,5 +4777,12 @@
"unknown_description": "Not downloaded by Trilium.",
"delete_foreign_confirmation": "Delete {{name}}? No feature of this app uses it.",
"unverified": "Not checked yet"
+ },
+ "template_properties": {
+ "title": "Template properties",
+ "title_template": "Default title of created notes",
+ "title_template_description": "Can read the time of creation (now) and the note it is created under (parentNote).",
+ "title_template_placeholder": "Meeting ${now.format('YYYY-MM-DD')}",
+ "new_notes": "New notes"
}
}
diff --git a/apps/client/src/widgets/bulk_actions/TemplateField.spec.tsx b/apps/client/src/widgets/bulk_actions/TemplateField.spec.tsx
index f390d9f25b..bed509bd92 100644
--- a/apps/client/src/widgets/bulk_actions/TemplateField.spec.tsx
+++ b/apps/client/src/widgets/bulk_actions/TemplateField.spec.tsx
@@ -43,6 +43,21 @@ describe("TemplateField", () => {
expect(refused.querySelector(".template-field-preview")).toBeNull();
});
+ it("shows the preview its caller gives, over the note's", async () => {
+ const note = buildNote({ title: "Meeting" });
+ vi.spyOn(note, "getMetadata").mockResolvedValue(METADATA);
+
+ let container: HTMLElement | undefined;
+ await act(async () => {
+ container = renderInto(
+ <TemplatePreviewNoteContext.Provider value={note.noteId}>
+ <TemplateField currentValue="${note.title}" preview="Given" onChange={() => {}} variables={{ note: "note" }} />
+ </TemplatePreviewNoteContext.Provider>
+ );
+ });
+ expect(container?.querySelector(".template-field-preview")?.textContent).toBe("template_field.preview:Given");
+ });
+
it("shows no preview without a note to preview against", async () => {
const container = await mount("NEW: ${note.title}", undefined);
expect(container.querySelector(".cm-editor")).not.toBeNull();
diff --git a/apps/client/src/widgets/bulk_actions/TemplateField.tsx b/apps/client/src/widgets/bulk_actions/TemplateField.tsx
index 2893ea9121..f9216a866e 100644
--- a/apps/client/src/widgets/bulk_actions/TemplateField.tsx
+++ b/apps/client/src/widgets/bulk_actions/TemplateField.tsx
@@ -23,6 +23,13 @@ export const TemplatePreviewNoteContext = createContext<string | undefined>(unde
interface TemplateFieldProps {
currentValue: string;
onChange(value: string): void;
+ /** Called when focus leaves the field, for a caller that saves the value then. */
+ onBlur?(): void;
+ /**
+ * The result shown below the field, for a caller that fills the template in itself. Without it,
+ * the template is filled in for the note in {@link TemplatePreviewNoteContext}.
+ */
+ preview?: string;
/** The variables the template can read, as the server passes them to `evaluateTemplate()`. */
variables: TemplateVariableTypes;
placeholder?: string;
@@ -34,11 +41,12 @@ interface TemplateFieldProps {
* coloured, completed and checked by the same rules the server applies, and the result for the note
* in {@link TemplatePreviewNoteContext} is shown below the field.
*/
-export default function TemplateField({ currentValue, onChange, variables, placeholder, ariaLabel }: TemplateFieldProps) {
+export default function TemplateField({ currentValue, onChange, onBlur, preview: givenPreview, variables, placeholder, ariaLabel }: TemplateFieldProps) {
const parentRef = useRef<HTMLDivElement>(null);
const onChangeRef = useRef(onChange);
onChangeRef.current = onChange;
- const preview = useTemplatePreview(currentValue, useContext(TemplatePreviewNoteContext));
+ const notePreview = useTemplatePreview(currentValue, useContext(TemplatePreviewNoteContext));
+ const preview = givenPreview ?? notePreview;
useEffect(() => {
if (!parentRef.current) return;
@@ -65,7 +73,7 @@ export default function TemplateField({ currentValue, onChange, variables, place
}, []);
return (
- <div className="template-field">
+ <div className="template-field" onBlur={onBlur}>
<div ref={parentRef} className={clsx(SEARCH_FIELD_EDITOR_CLASS, "form-control tn-input-field")} />
{preview && <div className="template-field-preview">{t("template_field.preview", { result: preview })}</div>}
</div>
diff --git a/apps/client/src/widgets/dialogs/template_properties.css b/apps/client/src/widgets/dialogs/template_properties.css
new file mode 100644
index 0000000000..57d2c80874
--- /dev/null
+++ b/apps/client/src/widgets/dialogs/template_properties.css
@@ -0,0 +1,4 @@
+.modal.template-properties-dialog .tn-card-option > .template-field {
+ flex: 0 1 55%;
+ min-width: 0;
+}
diff --git a/apps/client/src/widgets/dialogs/template_properties.spec.tsx b/apps/client/src/widgets/dialogs/template_properties.spec.tsx
new file mode 100644
index 0000000000..ea0ce0fcdf
--- /dev/null
+++ b/apps/client/src/widgets/dialogs/template_properties.spec.tsx
@@ -0,0 +1,126 @@
+import { act } from "preact/test-utils";
+import { describe, expect, it, vi } from "vitest";
+
+import Component from "../../components/component";
+import attributes from "../../services/attributes";
+import froca from "../../services/froca";
+import { buildNote } from "../../test/easy-froca";
+import { renderInto } from "../../test/render";
+import { ParentComponent } from "../react/react_utils";
+import TemplatePropertiesDialog from "./template_properties";
+
+vi.mock("../../services/i18n", async (importOriginal) => ({
+ ...await importOriginal<typeof import("../../services/i18n")>(),
+ t: (key: string, opts?: { result?: string }) => (opts?.result !== undefined ? `${key}:${opts.result}` : key)
+}));
+// The CodeMirror field has its own spec; a plain input stands in for it here.
+vi.mock("../bulk_actions/TemplateField", async (importOriginal) => ({
+ ...await importOriginal<typeof import("../bulk_actions/TemplateField")>(),
+ default: ({ currentValue, onChange, onBlur, preview, variables }: {
+ currentValue: string; onChange(value: string): void; onBlur?(): void; preview?: string;
+ variables: Record<string, string>;
+ }) => (<>
+ <input
+ className="title-template-stub" value={currentValue} data-variables={JSON.stringify(variables)}
+ onInput={(e) => onChange(e.currentTarget.value)} onBlur={onBlur}
+ />
+ {preview !== undefined && <span className="title-template-stub-preview">{preview}</span>}
+ </>)
+}));
+
+describe("TemplatePropertiesDialog", () => {
+ it("saves the template's own #template:titleTemplate when the field loses focus", async () => {
+ const setLabel = vi.spyOn(attributes, "setLabel").mockResolvedValue();
+ const note = buildNote({ title: "Meeting", "#template": "", "#template:titleTemplate": "Old" });
+
+ const { field } = await open(note.noteId);
+ expect(field.value).toBe("Old");
+ expect(JSON.parse(field.dataset.variables ?? "")).toEqual({ now: "date", parentNote: "note" });
+
+ // Leaving the field unchanged writes nothing.
+ await act(async () => {
+ field.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
+ });
+ expect(setLabel).not.toHaveBeenCalled();
+
+ type(field, "Meeting ${now.format('YYYY-MM-DD')}");
+ await act(async () => {
+ field.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
+ });
+ expect(setLabel).toHaveBeenCalledWith(note.noteId, "template:titleTemplate", "Meeting ${now.format('YYYY-MM-DD')}");
+ setLabel.mockRestore();
+ });
+
+ it("removes the label when the dialog closes on an emptied field", async () => {
+ const remove = vi.spyOn(attributes, "removeOwnedLabelByName").mockResolvedValue(true);
+ const note = buildNote({ title: "Meeting", "#template": "", "#template:titleTemplate": "Old" });
+
+ const { container, field } = await open(note.noteId);
+ type(field, "");
+ await act(async () => {
+ container.querySelector(".template-properties-dialog")
+ ?.dispatchEvent(new Event("hidden.bs.modal", { bubbles: true }));
+ });
+ expect(remove).toHaveBeenCalledWith(note, "template:titleTemplate");
+ remove.mockRestore();
+ });
+
+ it("previews the title below the field, filled in against the template's parent", async () => {
+ buildNote({
+ title: "Projects", children: [ { id: "tplPreview", title: "Meeting", "#template": "" } ]
+ });
+ const parent = froca.notes["tplPreview"]?.getParentNotes()[0];
+ expect(parent?.title).toBe("Projects");
+ if (parent) vi.spyOn(parent, "getMetadata").mockResolvedValue({
+ dateCreated: "2024-03-05 10:00:00.000+0100", dateModified: "2024-03-05 10:00:00.000+0100",
+ utcDateCreated: "2024-03-05 09:00:00.000Z", utcDateModified: "2024-03-05 09:00:00.000Z"
+ });
+
+ const { container, field } = await open("tplPreview");
+ const preview = () => container.querySelector(".template-properties-dialog .title-template-stub-preview");
+ expect(preview()).toBeNull();
+
+ type(field, "Notes for ${parentNote.title}");
+ await vi.waitFor(() => expect(preview()?.textContent).toBe("Notes for Projects"));
+
+ // A template the engine refuses has no preview.
+ type(field, "${parentNote.constructor}");
+ expect(preview()).toBeNull();
+ });
+
+ it("leaves a value inherited from the template's ancestors out of the field", async () => {
+ buildNote({
+ title: "Templates", "#template:titleTemplate(inheritable)": "Inherited",
+ children: [ { id: "tplPropsChild", title: "Meeting", "#template": "" } ]
+ });
+
+ const { field } = await open("tplPropsChild");
+ expect(field.value).toBe("");
+ });
+});
+
+async function open(noteId: string) {
+ const host = new Component();
+ const container = renderInto(
+ <ParentComponent.Provider value={host}>
+ <TemplatePropertiesDialog />
+ </ParentComponent.Provider>
+ );
+ await act(async () => {
+ await host.handleEventInChildren("showTemplateProperties", { noteId });
+ });
+ const field = await vi.waitFor(() => {
+ const input = container.querySelector<HTMLInputElement>(
+ ".template-properties-dialog .tn-card .title-template-stub");
+ if (!input) throw new Error("expected the title template field in a card");
+ return input;
+ });
+ return { container, field };
+}
+
+function type(field: HTMLInputElement, value: string) {
+ act(() => {
+ field.value = value;
+ field.dispatchEvent(new Event("input", { bubbles: true }));
+ });
+}
diff --git a/apps/client/src/widgets/dialogs/template_properties.tsx b/apps/client/src/widgets/dialogs/template_properties.tsx
new file mode 100644
index 0000000000..66fe94c7b3
--- /dev/null
+++ b/apps/client/src/widgets/dialogs/template_properties.tsx
@@ -0,0 +1,112 @@
+import "./template_properties.css";
+
+import { dayjs, evaluateTemplate } from "@triliumnext/commons";
+import { useEffect, useState } from "preact/hooks";
+
+import type FNote from "../../entities/fnote";
+import attributes from "../../services/attributes";
+import froca from "../../services/froca";
+import { t } from "../../services/i18n";
+import TemplateField, { noteTemplateVariables } from "../bulk_actions/TemplateField";
+import { CollectionPropertiesDialog } from "../note_bars/CollectionProperties";
+import { Card, OptionCardSection } from "../react/Card";
+import { useTriliumEvent } from "../react/hooks";
+
+/** What the server's `getNewNoteTitle()` passes to `evaluateTemplate()` for a title template. */
+const TITLE_TEMPLATE_VARIABLES = { now: "date", parentNote: "note" } as const;
+
+/**
+ * Edits what a template note sets on the notes created from it, starting with their title, as a
+ * column of cards like a collection's properties. Each setting is saved as it is changed.
+ */
+export default function TemplatePropertiesDialog() {
+ const [ note, setNote ] = useState<FNote>();
+ const [ shown, setShown ] = useState(false);
+ const [ titleTemplate, setTitleTemplate ] = useState("");
+ const preview = useTitlePreview(titleTemplate, note);
+
+ useTriliumEvent("showTemplateProperties", async ({ noteId }) => {
+ const templateNote = await froca.getNote(noteId);
+ if (!templateNote) return;
+ setTitleTemplate(templateNote.getOwnedLabelValue("template:titleTemplate") ?? "");
+ setNote(templateNote);
+ setShown(true);
+ });
+
+ async function saveTitleTemplate() {
+ if (!note) return;
+ const value = titleTemplate;
+ if (value === (note.getOwnedLabelValue("template:titleTemplate") ?? "")) return;
+ if (value) {
+ await attributes.setLabel(note.noteId, "template:titleTemplate", value);
+ } else {
+ await attributes.removeOwnedLabelByName(note, "template:titleTemplate");
+ }
+ }
+
+ return (
+ <CollectionPropertiesDialog
+ className="template-properties-dialog"
+ title={t("template_properties.title")}
+ show={shown}
+ onHidden={() => {
+ void saveTitleTemplate();
+ setShown(false);
+ }}
+ >
+ {shown && note && (
+ <Card heading={t("template_properties.new_notes")}>
+ <OptionCardSection
+ label={t("template_properties.title_template")}
+ description={t("template_properties.title_template_description")}
+ >
+ <TemplateField
+ key={note.noteId}
+ variables={TITLE_TEMPLATE_VARIABLES}
+ placeholder={t("template_properties.title_template_placeholder")}
+ ariaLabel={t("template_properties.title_template")}
+ preview={preview}
+ currentValue={titleTemplate}
+ onChange={setTitleTemplate}
+ onBlur={() => void saveTitleTemplate()}
+ />
+ </OptionCardSection>
+ </Card>
+ )}
+ </CollectionPropertiesDialog>
+ );
+}
+
+/**
+ * The title a note created from `templateNote` would get from `template` now, or `undefined`
+ * while it cannot be told. The template's own parent stands in for `parentNote`, since a template
+ * has no parent of its own for the notes created from it.
+ */
+function useTitlePreview(template: string, templateNote: FNote | undefined) {
+ const [ parentNote, setParentNote ] = useState<unknown>();
+
+ useEffect(() => {
+ let cancelled = false;
+ setParentNote(undefined);
+ const parent = templateNote?.getParentNotes()[0];
+ if (!parent) return;
+
+ // A preview that cannot be built is left out; the field works the same without it.
+ parent.getMetadata()
+ .then((metadata) => {
+ if (!cancelled) setParentNote(noteTemplateVariables(parent, metadata).note);
+ })
+ .catch(() => {});
+
+ return () => {
+ cancelled = true;
+ };
+ }, [ templateNote ]);
+
+ if (!template || !parentNote) return undefined;
+ try {
+ return evaluateTemplate(template, { now: dayjs(), parentNote });
+ } catch {
+ return undefined;
+ }
+}
diff --git a/apps/client/src/widgets/layout/NoteBadges.spec.tsx b/apps/client/src/widgets/layout/NoteBadges.spec.tsx
index 19ab6c96a6..b168ecad25 100644
--- a/apps/client/src/widgets/layout/NoteBadges.spec.tsx
+++ b/apps/client/src/widgets/layout/NoteBadges.spec.tsx
@@ -8,12 +8,17 @@ import { ViewScope } from "../../services/link";
// The badge reads the note being shown and the view it is shown in, neither of which a rendered
// widget brings with it.
-const shownNote = vi.hoisted(() => ({ current: null as FNote | null, viewScope: undefined as ViewScope | undefined }));
+const shownNote = vi.hoisted(() => ({
+ current: null as FNote | null,
+ viewScope: undefined as ViewScope | undefined,
+ parentComponent: { triggerEvent: vi.fn() }
+}));
vi.mock("../react/hooks", async (importOriginal) => ({
...(await importOriginal<typeof import("../react/hooks")>()),
useNoteContext: () => ({
note: shownNote.current,
- viewScope: shownNote.viewScope
+ viewScope: shownNote.viewScope,
+ parentComponent: shownNote.parentComponent
})
}));
@@ -129,6 +134,19 @@ describe("TemplateBadge", () => {
}
});
+ it("opens the template's properties dialog", async () => {
+ shownNote.current = buildNote({ title: "Meeting", "#template": "" });
+ await openScopes();
+
+ const properties = [ ...document.querySelectorAll<HTMLElement>(".tn-popup .dropdown-item") ]
+ .find((row) => row.textContent?.includes("breadcrumb_badges.template_properties"));
+ expect(properties).toBeDefined();
+ act(() => properties?.click());
+ expect(shownNote.parentComponent.triggerEvent)
+ .toHaveBeenCalledWith("showTemplateProperties", { noteId: shownNote.current.noteId });
+ document.body.replaceChildren();
+ });
+
function renderBadge(labels: Record<`#${string}`, string>) {
shownNote.current = buildNote({ title: "Meeting", ...labels });
return renderInto(<TemplateBadge />).querySelector(".template-badge");
@@ -148,7 +166,7 @@ describe("TemplateBadge", () => {
toggle?.click();
});
return await vi.waitFor(() => {
- const rows = [ ...document.querySelectorAll<HTMLElement>(".tn-popup .dropdown-item") ];
+ const rows = [ ...document.querySelectorAll<HTMLElement>(".tn-popup .dropdown-item[aria-checked]") ];
if (rows.length !== 2) throw new Error("expected the two scopes to be listed");
return rows;
});
diff --git a/apps/client/src/widgets/layout/NoteBadges.tsx b/apps/client/src/widgets/layout/NoteBadges.tsx
index f057c48c7b..2cebcab4bb 100644
--- a/apps/client/src/widgets/layout/NoteBadges.tsx
+++ b/apps/client/src/widgets/layout/NoteBadges.tsx
@@ -248,7 +248,7 @@ export function ExecuteBadge() {
* between `#template` and `#workspaceTemplate`; the latter only for a template inside a workspace.
*/
export function TemplateBadge() {
- const { note } = useNoteContext();
+ const { note, parentComponent } = useNoteContext();
const [ isTemplate ] = useNoteLabelBoolean(note, "template");
const [ isWorkspaceTemplate ] = useNoteLabelBoolean(note, "workspaceTemplate");
if (!note || (!isTemplate && !isWorkspaceTemplate)) return;
@@ -283,6 +283,11 @@ export function TemplateBadge() {
disabledTooltip={t("breadcrumb_badges.template_scope_workspace_unavailable")}
onClick={() => isTemplate && switchScope(true)}
>{t("breadcrumb_badges.template_scope_workspace")}</FormListItem>
+ <FormDropdownDivider />
+ <FormListItem
+ icon="bx bx-cog"
+ onClick={() => parentComponent?.triggerEvent("showTemplateProperties", { noteId: note.noteId })}
+ >{t("breadcrumb_badges.template_properties")}</FormListItem>
</BadgeWithDropdown>
);
}
diff --git a/apps/server/src/assets/help/help_content.json b/apps/server/src/assets/help/help_content.json
index 22b1845ac0..389961ae83 100644
--- a/apps/server/src/assets/help/help_content.json
+++ b/apps/server/src/assets/help/help_content.json
@@ -77,7 +77,7 @@
"_help_S0Fos78ZfcY7": "<p>The inbox is the default destination for quickly captured notes. When a note is created without picking a location first, it lands in the inbox. This makes it easy to quickly capture notes and sort them later.</p><h2>Where the inbox is used</h2><ul><li>The <em>New note</em> button in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_xYmIYSP6wE3F\">Launch Bar</a>.</li><li>The global <em>Create note into inbox</em> shortcut (default <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>P</kbd>).</li><li>The <em>New note</em> action in the <a href=\"#root/_help_7iwde4lsKc6O\">tray icon menu</a>.</li><li>The&nbsp;<a class=\"reference-link\" href=\"#root/_help_MtPxeAWVAzMg\">Web Clipper</a>&nbsp;extension.</li><li>The <em>Create note</em> option offered when a search finds no match, in&nbsp;<a class=\"reference-link\" href=\"#root/_help_F1r9QtzQLZqm\">Jump to &amp; command palette</a>, in an empty tab and in the <code>@</code> completion of a text note.</li></ul><h2>Setting a note inbox</h2><p>To create a note inbox, apply the <code>#inbox</code> <a href=\"#root/_help_HI6GBBIduIgv\">label</a> to it.</p><p>Only one note should carry this label. If there are multiple notes, only one will be used by the application.</p><aside class=\"admonition note\"><p>If there is no inbox note, Trilium will fall back to today's <a href=\"#root/_help_l0tKav7yLHGF\">day note</a>, creating it and its calendar ancestors as needed. If the journal has been removed altogether, the note is created at the top level instead of a new journal being built for it.</p></aside><h2>Workspace inboxes</h2><p>Each <a href=\"#root/_help_9sRHySam5fXb\">workspace</a> can have its own inbox, set via the <code>#workspaceInbox</code> label.</p><p>When a new note is created while hoisted in a workspace, the location is determined in the following order:</p><ul><li>A note carrying the <code>#workspaceInbox</code> label in that workspace.</li><li>A note carrying the <code>#inbox</code> within that workspace.</li><li>Today's <a href=\"#root/_help_l0tKav7yLHGF\">day note</a>, if the workspace has a <code>#workspaceCalendarRoot</code>.</li><li>The workspace root note itself.</li></ul>",
"_help_5Ct4MAJTS4tQ": "<p>Deleted notes are listed in the <em>Deleted Notes</em> dialog (<a class=\"reference-link\" href=\"#root/_help_x3i7MxGccDuM\">Global menu</a> → <em>Show Deleted Notes</em>) and can be restored by pressing the <em>undelete</em> link.</p><p>If a note has child notes, they will be restored along with it. Should the original location no longer exist (e.g. the parent has been deleted), the note will be restored into the default location for new notes (<a class=\"reference-link\" href=\"#root/_help_S0Fos78ZfcY7\">Note Inbox</a>).</p><aside class=\"admonition note\"><p>When a note is hoisted in the tree, the dialog will only display notes deleted from the subtree of that hoisted note.</p></aside><p>To permanently erase deleted notes and clear the list, press the three-dots menu and select <em>Erase deleted notes now</em>.</p><p>Deleted notes are permanently erased after a certain amount of time (7 days by default). To change this interval, press the three-dots menu and select <em>Deleted Notes Settings</em>.</p>",
"_help_m3VlURMSeOrd": "<p>When an empty&nbsp;<a class=\"reference-link\" href=\"#root/_help_iPIMuisry3hd\">Text</a>&nbsp;note is created, a note type switcher will appear below the&nbsp;inline&nbsp;<a class=\"reference-link\" href=\"#root/_help_l7pigIGu01K2\">Title</a>. Apart from changing the note type, it's also possible to apply a <a href=\"#root/_help_KC1HB96bqqHX\">template</a>:</p><ul><li><span class=\"tn-icon bx bxl-markdown\"></span>&nbsp;<em>Markdown</em> and&nbsp;<span class=\"tn-icon bx bx-pen\"></span> <em>Canvas</em> switch the note to that type in one click.</li><li><span class=\"tn-icon bx bx-code\"></span>&nbsp;<em>Code</em> lists the scripting notes (<em>Custom CSS</em>, <em>Widget</em> and <em>Backend script</em>), then the enabled code languages.</li><li><span class=\"tn-icon bx bx-book\"></span>&nbsp;<em>Collection</em> and <span class=\"tn-icon bx bx-copy-alt\"></span><em>Template</em> list the collections and the templates.</li><li><span class=\"tn-icon bx bx-dots-vertical-rounded\"></span>&nbsp;<em>All types</em> displays the same menu as <em>Insert note after</em> in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_YtSN43OrfzaA\">Note tree contextual menu</a>, with every note type and template.</li></ul><p>Typing while the&nbsp;<span class=\"tn-icon bx bx-code\"></span> <em>Code</em>,&nbsp;<span class=\"tn-icon bx bx-copy-alt\"></span> <em>Template</em> or&nbsp;<span class=\"tn-icon bx bx-dots-vertical-rounded\"></span> <em>All types</em> menu is open narrows it down to the matching entries.</p><p>The switcher will disappear as soon as a text is entered.</p><img src=\"{{helpAssets}}/User%20Guide/Basic%20Concepts%20and%20Features/Notes/New%20note%20type%20switcher_image.png\" width=\"735\" height=\"143\">",
- "_help_B5dihXRDksTk": "<p>Note badges appear near the fixed note title and indicate important information about the note such as whether it is read-only. Some of the badges are also interactive.</p><figure class=\"image\"><img style=\"aspect-ratio:910/49;\" src=\"{{helpAssets}}/User%20Guide/Basic%20Concepts%20and%20Features/Notes/Note%20badges_image.png\" width=\"910\" height=\"49\"></figure><p>The following badges are available:</p><ul><li><span class=\"tn-icon bx bx-lock-alt\"></span>&nbsp;<strong>Read-only badge</strong>, which will be shown if the note is not editable due to either automatic read-only or manual read-only. Clicking on the badge will temporarily edit the note. On the pages of the built-in user guide, which cannot be edited, the badge does nothing when clicked.</li><li><span class=\"tn-icon bx bx-share-alt\"></span>&nbsp;<strong>Share badge</strong>, which will indicate that the current note is shared. The badge will also indicate if the share is on the local network (for the desktop application without&nbsp;<a class=\"reference-link\" href=\"#root/_help_cbkrhQjrkKrh\">Synchronization</a>&nbsp;set up) or publicly accessible (for the server).</li><li><span class=\"tn-icon bx bx-globe\"></span>&nbsp;<strong>Web clip badge</strong>, which will indicate if the note was clipped using the&nbsp;<a class=\"reference-link\" href=\"#root/_help_MtPxeAWVAzMg\">Web Clipper</a>. The badge acts as a link, so it can be clicked on to navigate to the page or right clicked for more options. When the clipper also saved the page's description, its author, or the dates it was published and last updated, clicking the badge shows these details instead, with a link to the page at the top.</li><li><span class=\"tn-icon bx bx-play\"></span>&nbsp;<strong>Execute badge</strong>, for <a href=\"#root/_help_CdNpE2pqjmI6\">scripts</a> or <a href=\"#root/_help_YKWqdJhzi2VY\">saved SQL queries</a> which have an execute button or a description.</li><li><span class=\"tn-icon bx bx-copy-alt\"></span> <strong>Template badge</strong>, for&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a> (including workspace templates, for which the badge reads <em>Workspace template</em>). Notes created from a template inherit its attributes, so the badge is a reminder that changing them affects every such note. Clicking the badge switches the template between being offered everywhere and only while hoisted into its workspace, the latter being available only for a template inside a workspace (see&nbsp;<a class=\"reference-link\" href=\"#root/_help_9sRHySam5fXb\">Workspaces</a>).</li><li>For&nbsp;<a class=\"reference-link\" href=\"#root/_help_YzMcWlCVeW09\">Active content</a>&nbsp;(e.g. scripts, styles), a dedicated badge will be shown indicating the type of note and with an option to easily enable or disable it.</li></ul>",
+ "_help_B5dihXRDksTk": "<p>Note badges appear near the fixed note title and indicate important information about the note such as whether it is read-only. Some of the badges are also interactive.</p><figure class=\"image\"><img style=\"aspect-ratio:910/49;\" src=\"{{helpAssets}}/User%20Guide/Basic%20Concepts%20and%20Features/Notes/Note%20badges_image.png\" width=\"910\" height=\"49\"></figure><p>The following badges are available:</p><ul><li><span class=\"tn-icon bx bx-lock-alt\"></span>&nbsp;<strong>Read-only badge</strong>, which will be shown if the note is not editable due to either automatic read-only or manual read-only. Clicking on the badge will temporarily edit the note. On the pages of the built-in user guide, which cannot be edited, the badge does nothing when clicked.</li><li><span class=\"tn-icon bx bx-share-alt\"></span>&nbsp;<strong>Share badge</strong>, which will indicate that the current note is shared. The badge will also indicate if the share is on the local network (for the desktop application without&nbsp;<a class=\"reference-link\" href=\"#root/_help_cbkrhQjrkKrh\">Synchronization</a>&nbsp;set up) or publicly accessible (for the server).</li><li><span class=\"tn-icon bx bx-globe\"></span>&nbsp;<strong>Web clip badge</strong>, which will indicate if the note was clipped using the&nbsp;<a class=\"reference-link\" href=\"#root/_help_MtPxeAWVAzMg\">Web Clipper</a>. The badge acts as a link, so it can be clicked on to navigate to the page or right clicked for more options. When the clipper also saved the page's description, its author, or the dates it was published and last updated, clicking the badge shows these details instead, with a link to the page at the top.</li><li><span class=\"tn-icon bx bx-play\"></span>&nbsp;<strong>Execute badge</strong>, for <a href=\"#root/_help_CdNpE2pqjmI6\">scripts</a> or <a href=\"#root/_help_YKWqdJhzi2VY\">saved SQL queries</a> which have an execute button or a description.</li><li><span class=\"tn-icon bx bx-copy-alt\"></span> <strong>Template badge</strong>, for&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a> (including workspace templates, for which the badge reads <em>Workspace template</em>). Notes created from a template inherit its attributes, so the badge is a reminder that changing them affects every such note. Clicking the badge switches the template between being offered everywhere and only while hoisted into its workspace, the latter only for a template inside a workspace (see&nbsp;<a class=\"reference-link\" href=\"#root/_help_9sRHySam5fXb\">Workspaces</a>). It also opens <em>Template properties...</em>, where the default title of new notes is set.</li><li>For&nbsp;<a class=\"reference-link\" href=\"#root/_help_YzMcWlCVeW09\">Active content</a>&nbsp;(e.g. scripts, styles), a dedicated badge will be shown indicating the type of note and with an option to easily enable or disable it.</li></ul>",
"_help_Bsm4fyzPJkSc": "<p><img class=\"image-style-align-right\" src=\"{{helpAssets}}/User%20Guide/Basic%20Concepts%20and%20Features/Notes/Save%20status%20indicator_image.png\" width=\"168\" height=\"47\">To the right of the note title, a temporary indicator appears after making a change to the document which shows whether the document has been saved.</p><p>It indicates the following states:</p><ul><li><span class=\"tn-icon bx bx-pencil\"></span>&nbsp;<em>Unsaved</em>, if the changes will be saved soon.</li><li><span class=\"tn-icon bx bx-loader\"></span>&nbsp;<em>Saving</em>, if the changes are being saved.</li><li><span class=\"tn-icon bx bx-check\"></span>&nbsp;<em>Saved</em>, if all the changes were successfully saved to the server.</li><li><span class=\"tn-icon bx bx-error\"></span>&nbsp;<em>Error</em>, if the changes could not be saved, for example due to a communication server with the server.</li></ul><p>After all changes have been saved, the indicator will hide automatically after a few seconds.</p>",
"_help_kBrnXNG3Hplm": "<p>This page explains the basic concepts related to the tree structure of notes in TriliumNext.</p><h2>Note</h2><p>A note is the central entity in TriliumNext. For more details, see&nbsp;<a class=\"reference-link\" href=\"#root/_help_BFs8mudNFgCS\">Notes</a>.</p><h2>Branch</h2><p>A branch describes the placement of a note within the note tree. Essentially, it is a tuple of <code>parentNoteId</code> and <code>noteId</code>, indicating that the given note is placed as a child under the specified parent note.</p><p>Each note can have multiple branches, meaning any note can be placed in multiple locations within the tree. This concept is referred to as&nbsp;<a class=\"reference-link\" href=\"#root/_help_IakOLONlIfGI\">Cloning Notes</a>.</p><h2>Prefix</h2><p>A prefix is a branch-specific title modifier for a note. If you place your note in two different locations within the tree and want to alter the title slightly in one of those placements, you can use a prefix.</p><p>To edit a prefix, right-click on the note in the tree pane and select <em>Edit branch prefix</em>.</p><p>The prefix is not part of the note itself and is not encrypted when the note is protected. This can be useful if you want part of the title to remain visible in the tree for easier navigation, even when the note is protected.</p><h2>Subtree</h2><p>A subtree consists of a particular note (the subtree root) and all its children and descendants. Some operations, such as exporting, work on entire subtrees.</p>",
"_help_MMiBEQljMQh2": "<p>One of the Trilium's goals is to provide fast and comfortable navigation between notes.</p><h2>Backwards and forward</h2><p>You can use alt-left and alt-right to move back and forward in history of viewed pages.</p><p>This works identically to browser backwards / forwards, it's actually using built-in browser support for this.</p><p><img src=\"{{helpAssets}}/User%20Guide/Basic%20Concepts%20and%20Features/Navigation/Note%20Navigation_image.jpg\"></p><h2>Jump to note</h2><p>This is useful to quickly find and view arbitrary notes - click on <code>Jump to</code> button on the top or press <kbd>Ctrl</kbd> + <kbd>J</kbd> . Then type part of the note name and autocomplete will help you pick the desired note.</p><p>See&nbsp;<a class=\"reference-link\" href=\"#root/_help_F1r9QtzQLZqm\">Jump to Note</a>&nbsp;for more information.</p>",
@@ -202,7 +202,7 @@
"_help_Cq5X6iKQop6R": "<p>A relation is similar to a <a href=\"#root/_help_HI6GBBIduIgv\">label</a>, but instead of having a text value it refers to another note.</p><h2>Common use cases</h2><ul><li><strong>Metadata Relationships for personal use</strong>: For example, linking a book note to an author note.<br>This can be combined with&nbsp;<a class=\"reference-link\" href=\"#root/_help_OFXdgB2nNk1F\">Promoted Attributes</a>&nbsp;to make their display more user-friendly.</li><li><strong>Configuration</strong>: For configuring some notes such as&nbsp;<a class=\"reference-link\" href=\"#root/_help_HcABDtFCkbFN\">Render Note</a>, or configuring&nbsp;<a class=\"reference-link\" href=\"#root/_help_R9pX4DGra2Vt\">Sharing</a>&nbsp;or&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>&nbsp;(see the list below).</li><li><strong>Scripting</strong>: Attaching scripts to events or conditions related to the note.</li></ul><h2>Creating a relation using the visual editor</h2><ol><li>Go to the&nbsp;<a class=\"reference-link\" href=\"#root/_help_uNtgN0cUKEBc\">Attributes tab</a>&nbsp;in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_RnaPdbciOfeq\">Right Sidebar</a>.</li><li>Press the&nbsp;<span class=\"tn-icon bx bx-plus\"></span> button (<em>Add a new attribute</em>) to the right of the <em>Owned attributes</em> section.</li><li>Select <em>Add new relation</em> for the relation.</li></ol><p>While in the visual editor, set the desired name and the <em>Target note</em> (the note to point to). Unlike labels, relations cannot exist with a target note.</p><p>Children can inherit this relation, click the relation and check <em>Inheritable</em>. See&nbsp;<a class=\"reference-link\" href=\"#root/_help_bwZpz2ajCEwO\">Attribute Inheritance</a>&nbsp;for more information.</p><aside class=\"admonition tip\"><p>Alternatively, press <kbd>Alt</kbd>+<kbd>L</kbd> which will open the attribute details (same view as when an existing attribute is clicked) in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_AlJ73vBCjWDw\">Status bar</a>.</p></aside><h2>Creating a relation manually</h2><p>In the&nbsp;<a class=\"reference-link\" href=\"#root/_help_AlJ73vBCjWDw\">Status bar</a>, press the&nbsp;<span class=\"tn-icon bx bx-list-check\"></span> button to show the list of the attributes.</p><ul><li>To create a relation called <code>myRelation</code>:<ol><li>Click the input box to focus it.</li><li>Type <code>~myRelation=@</code> .</li><li>After this, an autocompletion box should appear.</li><li>Type the title of the note to point to and press <kbd>Enter</kbd> to confirm (or click the desired note).</li><li>Alternatively copy a note from the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>&nbsp;and paste it after the <code>=</code> sign (without the <code>@</code> , in this case).</li></ol></li><li>To create an inheritable relation, follow the same steps as previously described but instead of <code>~myRelation</code> write <code>~myRelation(inheritable)</code>.</li></ul><h2>Predefined relations</h2><p>These relations are supported and used internally by Trilium.</p><figure class=\"table\"><table><thead><tr><th>Label</th><th>Description</th></tr></thead><tbody><tr><td><code>runOn*</code></td><td>See&nbsp;<a class=\"reference-link\" href=\"#root/_help_GPERMystNGTB\">Backend Events</a></td></tr><tr><td><code>template</code></td><td>note's attributes will be inherited even without a parent-child relationship, note's content and subtree will be added to instance notes if empty. See documentation for details.</td></tr><tr><td><code>template:newNoteDefaultParent</code></td><td>set on a template note, points to the note under which notes created from the template are placed when no other location is picked; when set several times, the note is cloned into every target. See&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>.</td></tr><tr><td><code>inherit</code></td><td>note's attributes will be inherited even without a parent-child relationship. See&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>&nbsp;for a similar concept. See&nbsp;<a class=\"reference-link\" href=\"#root/_help_bwZpz2ajCEwO\">Attribute Inheritance</a>&nbsp;in the documentation.</td></tr><tr><td><code>renderNote</code></td><td>notes of type&nbsp;<a class=\"reference-link\" href=\"#root/_help_HcABDtFCkbFN\">Render Note</a>&nbsp;will be rendered using a code note (HTML or script) and it is necessary to point using this relation to which note should be rendered</td></tr><tr><td><code>widget</code></td><td>Used in the context of custom&nbsp;<a class=\"reference-link\" href=\"#root/_help_4Gn3psZKsfSm\">Launch Bar Widgets</a>, to refer to the widget that will be rendered.</td></tr><tr><td><code>shareCss</code></td><td>CSS note which will be injected into the share page. CSS note must be in the shared sub-tree as well. Consider using <code>shareHiddenFromTree</code> and <code>shareOmitDefaultCss</code> as well.</td></tr><tr><td><code>shareJs</code></td><td>JavaScript note which will be injected into the share page. JS note must be in the shared sub-tree as well. Consider using <code>shareHiddenFromTree</code>.</td></tr><tr><td><code>shareHtml</code></td><td>HTML note which will be injected into the share page at locations specified by the <code>shareHtmlLocation</code> label. HTML note must be in the shared sub-tree as well. Consider using <code>shareHiddenFromTree</code>.</td></tr><tr><td><code>shareTemplate</code></td><td>Embedded JavaScript note that will be used as the template for displaying the shared note. Falls back to the default template. Consider using <code>shareHiddenFromTree</code>.</td></tr><tr><td><code>shareFavicon</code></td><td>Favicon note to be set in the shared page. Typically you want to set it to share root and make it inheritable. Favicon note must be in the shared sub-tree as well. Consider using <code>shareHiddenFromTree</code>.</td></tr></tbody></table></figure>",
"_help_bwZpz2ajCEwO": "<p>Inheritance refers to the process of having a <a href=\"#root/_help_HI6GBBIduIgv\">label</a> or a <a href=\"#root/_help_Cq5X6iKQop6R\">relation</a> shared across multiple notes, generally in parent-child relations (or anywhere if using templates).</p><h2>Standard Inheritance</h2><p>In Trilium, attributes can be automatically inherited by child notes if they have the <code>isInheritable</code> flag set to <code>true</code>. This means the attribute (a key-value pair) is applied to the note and all its descendants.</p><p>To make an attribute inheritable, simply use the visual editor for&nbsp;<a class=\"reference-link\" href=\"#root/_help_HI6GBBIduIgv\">Labels</a>&nbsp;or&nbsp;<a class=\"reference-link\" href=\"#root/_help_Cq5X6iKQop6R\">Relations</a>. Alternatively, the attribute can be manually defined where <code>#myLabel=value</code> becomes <code>#myLabel(inheritable)=value</code> when inheritable.</p><p>As an example, the <code>archived</code> label can be set to be inheritable, allowing you to hide a whole subtree of notes from searches and other dialogs by applying this label at the top level.</p><p>Standard inheritance forces all the notes that are children (and sub-children) of a note to have that particular label or relation. If there is a need to have some notes not inherit one of the labels, then <em>copying inheritance</em> or <em>template inheritance</em> needs to be used instead.</p><h2>Copying Inheritance</h2><p>Copying inheritance differs from standard inheritance by using a <code>child:</code> prefix in the attribute name. This prefix causes new child notes to automatically receive specific attributes from the parent note. These attributes are independent of the parent and will persist even if the note is moved elsewhere.</p><p>If a parent note has the label <code>#child:exampleAttribute</code>, all newly created child notes (one level deep) will inherit the <code>#exampleAttribute</code> label. This can be useful for setting default properties for notes in a specific section.</p><p>Similarly, for relations use <code>~child:myRelation</code>.</p><p>Due to the way it's designed, copying inheritance cannot be used to cascade infinitely within a hierarchy. For that use case, consider using either standard inheritance or templates.</p><h3>Chained inheritance</h3><p>It is possible to define labels across multiple levels of depth. For example, <code>#child:child:child:foo</code> applied to a root note would create:</p><ul><li><code>#child:child:foo</code> on the first-level children.</li><li><code>#child:foo</code> on the second-level children.</li><li><code>#foo</code> on the third-level children.</li></ul><p>Similarly, use <code>~child:child:child:foo</code> if dealing with relations.</p><p>Do note that same as simple copying inheritance, the changes will not apply retroactively to existing notes in the hierarchy, it will only apply to the newly created notes.</p><h2>Template Inheritance</h2><p>Attributes can also be inherited from&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>. When a new note is created using a template, it inherits the attributes defined in that template. This is particularly useful for maintaining consistency across notes that follow a similar structure or function.</p>",
"_help_OFXdgB2nNk1F": "<figure class=\"image image_resized\" style=\"width:61.4%;\"><img style=\"aspect-ratio:938/368;\" src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Attributes/Promoted%20Attributes_image.png\" width=\"938\" height=\"368\"></figure><p>Promoted attributes are <a href=\"#root/_help_zEY4DaJG4YT5\">attributes</a> which are displayed prominently in the UI which allow them to be easily viewed and edited.</p><p>The promoted attributes are shown underneath the&nbsp;<a class=\"reference-link\" href=\"#root/_help_l7pigIGu01K2\">Title</a>&nbsp;of the note, in a collapsible section. For full-height notes such as&nbsp;<a class=\"reference-link\" href=\"#root/_help_grjYqerjn243\">Canvas</a>, the promoted attributes are collapsed by default to make room.</p><p>One way of seeing promoted attributes is as a kind of form with several fields. Each field is just regular attribute, the only difference is that they appear on the note itself.</p><p>Attributes can be pretty useful since they allow for querying and script automation etc. but they are also inconveniently hidden. This allows you to select few of the important ones and push them to the front of the user.</p><h2>Attribute definition</h2><figure class=\"image image-style-align-right image_resized\" style=\"width:50%;\"><img style=\"aspect-ratio:885/742;\" src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Attributes/2_Promoted%20Attributes_image.png\" width=\"885\" height=\"742\"></figure><p>In order to have promoted attributes, there needs to be a way to define them.</p><p>Technically, attributes are only name-value pairs where both name and value are strings.</p><p>The <em>Attribute definition</em> specifies how should this value be interpreted:</p><ul><li>Is it just string, or is it a date?</li><li>Should we allow multiple values or note?</li><li>Should we <em>promote</em> the attribute or not?</li></ul><h2>Types of attributes</h2><p>Attribute definitions have a dedicated type field which will change how the value will be edited in the promoted attributes section.</p><p>The following types are supported:</p><ul><li><em>Text</em>, the default option which allows any type of text to be edited, similar to normal labels that don't have a type associated.</li><li><em>Multi-line text</em>, similar to a normal text field, but rendered in a bigger text box that also supports writing on multiple lines.</li><li><em>Number</em>, will display as a number input field with up/down arrows.<ul><li>Optionally a <em>precision</em> which sets how many decimals the value steps by and is displayed with.</li></ul></li><li><em>Checkbox</em>, which renders as a checkbox for a true/false value. In the label definition, this type is written as <code>boolean</code>.</li><li><em>Select,</em> which provides a list of user-defined options when editing.<ul><li>The list is not fixed, meaning that new options can be easily added from the promoted attribute.</li><li>Renaming an option does not change the existing values since the value is stored as text. Consider a <a href=\"#root/_help_ivYnonVFBxbQ\">bulk rename</a>.</li><li>The items do not have a custom color or icon. This is intentional as selects are meant to be light-weight. For a more customizable option, consider using&nbsp;<a class=\"reference-link\" href=\"#root/_help_Cq5X6iKQop6R\">Relations</a>&nbsp;instead which use notes as items and those notes can be colorized and also carry an icon.</li></ul></li><li><em>Date,</em> which provides a date picker.</li><li><em>Date &amp; Time,</em> which provides a date &amp; time picker.</li><li><em>Time,</em> which provides a time picker.</li><li><em>URL,</em> which provides a button to open the web address in a new window.</li><li><em>Email</em>, which provides a button to quickly send an email to that address using your operating system's default app.</li><li><em>Phone</em>, which provides a button to quickly call that number using your operating system's default app.</li><li><em>Color</em>, which provides a color picker and a way to remove the value.</li><li><em>Relation</em>, which points to another note and uses&nbsp;<a class=\"reference-link\" href=\"#root/_help_Cq5X6iKQop6R\">Relations</a>&nbsp;instead of&nbsp;<a class=\"reference-link\" href=\"#root/_help_HI6GBBIduIgv\">Labels</a>.</li></ul><aside class=\"admonition note\"><p>For label-based attributes, these types are not enforced by the attribute system, meaning that changing the type afterwards does not guarantee that the values in it correspond to the type (e.g. turning a text into a number).</p></aside><h2>Multiple values</h2><p>When the definition allows multiple values, each value is shown as a chip and a new one is added in the box after them. Press the <span class=\"tn-icon bx bx-x\"></span> on a chip to remove that value.</p><ul><li>For free-form types such as <em>Text</em>, <em>Number</em> or <em>Date</em>, press <kbd>Enter</kbd> (or leave the field) to add what was typed. The same value can be added more than once, for example two payments of the same amount.</li><li>For <em>Select</em>, <em>Checkbox</em> and <em>Relation</em> attributes, a value is picked from the list rather than typed, and each one can be picked only once.</li></ul><h2>Creating a new promoted attribute definition</h2><p>To create a new promoted attribute:</p><ol><li>Go to a note.</li><li>Go to the&nbsp;<a class=\"reference-link\" href=\"#root/_help_uNtgN0cUKEBc\">Attributes tab</a>&nbsp;in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_RnaPdbciOfeq\">Right Sidebar</a>.</li><li>Press the&nbsp;<span class=\"tn-icon bx bx-plus\"></span> button for the top-most section (<em>Owned attributes</em>).</li><li>Select either <em>Add new label definition…</em> or <em>Add new relation definition…</em>.</li><li>Select the name which will be name of the label or relation that will be created when the promoted attribute is edited.</li><li>Ensure <em>Promoted</em> is checked in order to display it at the top of notes.</li><li>Optionally, choose an <em>Alias</em> which will be displayed next to the promoted attribute instead of the attribute name. Generally it's best to choose a “user-friendly” name since it can contain spaces and other characters which are not supported as attribute names.</li><li>Check <em>Inheritable</em> to apply it to this note and all its descendants. To keep it only for the current note, un-check it.</li><li>Press <em>Save &amp; Close</em> to apply the changes.</li></ol><p>Alternatively, promoted attributes can be created from the&nbsp;<a class=\"reference-link\" href=\"#root/_help_AlJ73vBCjWDw\">Status bar</a>&nbsp;by going to&nbsp;<span class=\"tn-icon bx bx-list-check\"></span> (<em>Attributes</em>), pressing the&nbsp;<span class=\"tn-icon bx bx-plus\"></span> button and selecting <em>Add new label definition…</em>. The resulting attribute can also be copy-pasted or written manually (albeit discouraged).</p><h2>How attribute definitions actually work</h2><p>When a new promoted attribute definition is created, it creates a corresponding label prefixed with either <code>label</code> or <code>relation</code>, depending on the definition type:</p><pre><code class=\"language-text-x-trilium-auto\">#label:myColor(inheritable)=\"promoted,alias=Color,multi,color\"</code></pre><p>The only purpose of the attribute definition is to set up a template. If the attribute was marked as promoted, then it's also displayed to the user for easy editing.</p><figure class=\"table\"><table><tbody><tr><td><figure class=\"image\"><img style=\"aspect-ratio:495/157;\" src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Attributes/1_Promoted%20Attributes_image.png\" width=\"495\" height=\"157\"></figure></td><td>Notice how the promoted attribute definition only creates a “Due date” box above the text content.</td></tr><tr><td><figure class=\"image\"><img style=\"aspect-ratio:663/160;\" src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Attributes/3_Promoted%20Attributes_image.png\" width=\"663\" height=\"160\"></figure></td><td>Once a value is set by the user, a new label (or relation, depending on the type) is created. The name of the attribute matches one set when creating the promoted attribute.</td></tr></tbody></table></figure><p>So there's one attribute for value and one for definition. But notice how an definition attribute can be made <a href=\"#root/_help_bwZpz2ajCEwO\">Inheritable</a>, meaning that it's also applied to all descendant notes. In this case, the definition used for the whole sub-tree while \"value\" attributes are for each not individually.</p><h2>Using system attributes</h2><p>It's possible to create promoted attributes out of system attributes, to be able to easily alter them.</p><p>Here are a few practical examples:</p><ul><li><a class=\"reference-link\" href=\"#root/_help_GTwFsgaA0lCt\">Collections</a>&nbsp;already make use of this practice, for example:<ul><li>Calendars add “Start Date”, “End Date”, “Start Time” and “End Time” as promoted attributes. These map to system attributes such as <code>startDate</code> which are then interpreted by the calendar view.</li><li><a class=\"reference-link\" href=\"#root/_help_zP3PMqaG71Ct\">Presentation</a>&nbsp;adds a “Background” promoted attribute for each of the slide to easily be able to customize.</li></ul></li><li>The Trilium documentation (which is edited in Trilium) uses a promoted attribute to be able to easily edit the <code>#shareAlias</code> (see&nbsp;<a class=\"reference-link\" href=\"#root/_help_R9pX4DGra2Vt\">Sharing</a>) in order to form clean URLs.</li><li>If you always edit a particular system attribute such as <code>#color</code>, simply create a promoted attribute for it to make it easier.</li></ul><h3>Inverse relation</h3><p>Some relations always occur in pairs - my favorite example is on the family. If you have a note representing husband and note representing wife, then there might be a relation between those two of <code>isPartnerOf</code>. This is bidirectional relationship - meaning that if a relation is pointing from husband to wife then there should be always another relation pointing from wife to husband.</p><p>Another example is with parent-child relationship. Again these always occur in pairs, but in this case it's not exact same relation - the one going from parent to child might be called <code>isParentOf</code> and the other one going from child to parent might be called <code>isChildOf</code>.</p><p>Relation definition allows you to specify such \"inverse relation\" - for the relation you just define you specify which is the inverse relation. Note that in the second example we should have two relation definitions - one for <code>isParentOf</code> which defines <code>isChildOf</code> as inverse relation and then second relation definition for <code>isChildOf</code> which defines <code>isParentOf</code> as inverse relation.</p><p>What this does internally is that whenever we save a relation which has defined inverse relation, we check that this inverse relation exists on the relation target note. Similarly, when we delete relation, we also delete inverse relation on the target note.</p><h2>See also</h2><ul><li>The&nbsp;<a class=\"reference-link\" href=\"#root/_help_2FvYrpmOXm29\">Table</a>&nbsp;collection makes heavy use of promoted attributes to define the columns of the table, since they already carry the type information. When made inheritable, it's also easy to change those fields when the child notes are opened.</li></ul>",
- "_help_KC1HB96bqqHX": "<p>A template in Trilium serves as a predefined structure for other notes, referred to as instance notes. Assigning a template to a note brings three main effects:</p><ol><li><strong>Attribute Inheritance</strong>: All attributes from the template note are <a href=\"#root/_help_bwZpz2ajCEwO\">inherited</a> by the instance notes. Even attributes with <code>#isInheritable=false</code> are inherited by the instance notes, although only inheritable attributes are further inherited by the children of the instance notes.</li><li><strong>Content Duplication</strong>: The content of the template note is copied to the instance note, provided the instance note is empty at the time of template assignment.</li><li><strong>Child Note Duplication</strong>: All child notes of the template are deep-duplicated to the instance note.</li></ol><h2>Example</h2><p>A typical example would be a \"Book\" template note, which might include:</p><ul><li><strong>Promoted Attributes</strong>: Such as publication year, author, etc. (see <a href=\"#root/_help_OFXdgB2nNk1F\">promoted attributes</a>).</li><li><strong>Outline</strong>: An outline for a book review, including sections like themes, conclusion, etc.</li><li><strong>Child Notes</strong>: Additional notes for highlights, summary, etc.</li></ul><p><img src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Templates_template.png\" alt=\"Template Example\"></p><h2>Instance Note</h2><p>An instance note is a note related to a template note. This relationship means the instance note's content is initialized from the template, and all attributes from the template are inherited.</p><p>To create an instance note through the UI:</p><p><img src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Templates_template-create-instance-note.png\" alt=\"show child note templates\"></p><p>For the template to appear in the menu, the template note must have the <code>#template</code> label. Do not confuse this with the <code>~template</code> relation, which links the instance note to the template note. If you use <a href=\"#root/_help_9sRHySam5fXb\">workspaces</a>, you can also mark templates with <code>#workspaceTemplate</code> to display them only in the workspace.</p><p>Templates can also be added or changed after note creation by creating a <code>~template</code> relation pointing to the desired template note.&nbsp;</p><p>To specify a template for child notes, you can use a <code>~child:template</code> relation pointing to the appropriate template note. There is no limit to the depth of the hierarchy — you can use <code>~child:child:template</code>, <code>~child:child:child:template</code>, and so on.</p><aside class=\"admonition important\"><p>Changing the template hierarchy after the parent note is created will not retroactively apply to newly created child notes.<br>For example, if you initially use <code>~child:template</code> and later switch to <code>~child:child:template</code>, it will not automatically apply the new template to the grandchild notes. Only the structure present at the time of note creation is considered.</p></aside><h2>Default parent for new notes</h2><p>A template can gather the notes created from it in one place, instead of having them land wherever they happen to be created. To do so, add a <code>~template:newNoteDefaultParent</code> relation to the template note, pointing at the note that should hold the instances, for example a <em>Person</em> template pointing to a <em>People</em> note.</p><p>Adding the relation several times places the new note in every target, as&nbsp;<a class=\"reference-link\" href=\"#root/_help_IakOLONlIfGI\">Cloning Notes</a>. The relation can also be inherited (e.g. from a folder holding several templates), in which case a relation owned by the template itself replaces the inherited one. The default parent is only inherited from the template's ancestors in the tree: a template created from another template does not adopt that template's default parent.</p><p>The default parent is used whenever a note is created from the template through the <em>Choose note type</em> dialog:</p><ul><li>Via <code>@</code>-completion in a&nbsp;<a class=\"reference-link\" href=\"#root/_help_iPIMuisry3hd\">Text</a>&nbsp;note</li><li>Via the <em>Create note</em> or <em>Create child note</em> options of the note search (new tab or&nbsp;<a class=\"reference-link\" href=\"#root/_help_hrZ1D00cLbal\">Internal (reference) links</a>), but only if the default/empty location is set.</li></ul><p>Creating an instance note from the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>&nbsp;context menu (<em>Insert child note</em>, <em>Insert note after</em>) still creates it at the chosen place.</p><p>Unlike the&nbsp;<a class=\"reference-link\" href=\"#root/_help_S0Fos78ZfcY7\">Note Inbox</a>, which holds quickly captured notes until they are sorted, the default parent is meant as the instances' permanent location.</p><h2>Regarding note types</h2><p>By default, newly created notes are&nbsp;<a class=\"reference-link\" href=\"#root/_help_iPIMuisry3hd\">Text</a>&nbsp;notes. If a parent note defines a <code>child:template</code> pointing to a template of a different type (e.g. a Code note), the behavior depends on how the new note is created:</p><ul><li>If no note type is explicitly chosen (e.g. the + button in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>), the template is applied and the new note takes the type and content of the template.</li><li>If a note type is explicitly selected (e.g.&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>&nbsp;→ <em>Insert note after</em> / <em>Insert child note</em>):<ul><li>If the selected type matches the template's type, the template is applied.</li><li>If the selected type differs, the template is disregarded entirely — the new note is an empty note of the selected type.</li></ul></li></ul><p>Selecting a specific template from the creation menu always takes precedence over <code>child:template</code>.</p><h2>Default title for new notes</h2><p>A template can also give its instances a default title, using the <code>#template:titleTemplate</code> label. See <a class=\"reference-link\" href=\"#root/_help_47ZrP6FNuoG8\">Default Note Title</a> for details.</p><h2>Additional Notes</h2><p>From a visual perspective, templates can define <code>#iconClass</code> and <code>#cssClass</code> attributes, allowing all instance notes (e.g., books) to display a specific icon and CSS style.</p><p>Explore the concept further in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_6tZeKvSHEUiB\">Demo Notes</a>, including examples like the&nbsp;<a class=\"reference-link\" href=\"#root/_help_iRwzGnHPzonm\">Relation Map</a>,&nbsp;<a class=\"reference-link\" href=\"#root/_help_xYjQUYhpbUEW\">Task Manager</a>, and&nbsp;<a class=\"reference-link\" href=\"#root/_help_l0tKav7yLHGF\">Day Notes</a>.</p><p>Additionally, see&nbsp;<a class=\"reference-link\" href=\"#root/_help_47ZrP6FNuoG8\">Default Note Title</a>&nbsp;for creating title templates. A <code>#titleTemplate</code> on a template note is passed on to its instances like any other label, so it names the children of each instance rather than the instances themselves; to name the instances, use <code>#template:titleTemplate</code>.</p>",
+ "_help_KC1HB96bqqHX": "<p>A template in Trilium serves as a predefined structure for other notes, referred to as instance notes. Assigning a template to a note brings three main effects:</p><ol><li><strong>Attribute Inheritance</strong>: All attributes from the template note are <a href=\"#root/_help_bwZpz2ajCEwO\">inherited</a> by the instance notes. Even attributes with <code>#isInheritable=false</code> are inherited by the instance notes, although only inheritable attributes are further inherited by the children of the instance notes.</li><li><strong>Content Duplication</strong>: The content of the template note is copied to the instance note, provided the instance note is empty at the time of template assignment.</li><li><strong>Child Note Duplication</strong>: All child notes of the template are deep-duplicated to the instance note.</li></ol><h2>Example</h2><p>A typical example would be a \"Book\" template note, which might include:</p><ul><li><strong>Promoted Attributes</strong>: Such as publication year, author, etc. (see <a href=\"#root/_help_OFXdgB2nNk1F\">promoted attributes</a>).</li><li><strong>Outline</strong>: An outline for a book review, including sections like themes, conclusion, etc.</li><li><strong>Child Notes</strong>: Additional notes for highlights, summary, etc.</li></ul><p><img src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Templates_template.png\" alt=\"Template Example\"></p><h2>Instance Note</h2><p>An instance note is a note related to a template note. This relationship means the instance note's content is initialized from the template, and all attributes from the template are inherited.</p><p>To create an instance note through the UI:</p><p><img src=\"{{helpAssets}}/User%20Guide/Advanced%20Usage/Templates_template-create-instance-note.png\" alt=\"show child note templates\"></p><p>For the template to appear in the menu, the template note must have the <code>#template</code> label. Do not confuse this with the <code>~template</code> relation, which links the instance note to the template note. If you use <a href=\"#root/_help_9sRHySam5fXb\">workspaces</a>, you can also mark templates with <code>#workspaceTemplate</code> to display them only in the workspace.</p><p>Templates can also be added or changed after note creation by creating a <code>~template</code> relation pointing to the desired template note.&nbsp;</p><p>To specify a template for child notes, you can use a <code>~child:template</code> relation pointing to the appropriate template note. There is no limit to the depth of the hierarchy — you can use <code>~child:child:template</code>, <code>~child:child:child:template</code>, and so on.</p><aside class=\"admonition important\"><p>Changing the template hierarchy after the parent note is created will not retroactively apply to newly created child notes.<br>For example, if you initially use <code>~child:template</code> and later switch to <code>~child:child:template</code>, it will not automatically apply the new template to the grandchild notes. Only the structure present at the time of note creation is considered.</p></aside><h2>Default parent for new notes</h2><p>A template can gather the notes created from it in one place, instead of having them land wherever they happen to be created. To do so, add a <code>~template:newNoteDefaultParent</code> relation to the template note, pointing at the note that should hold the instances, for example a <em>Person</em> template pointing to a <em>People</em> note.</p><p>Adding the relation several times places the new note in every target, as&nbsp;<a class=\"reference-link\" href=\"#root/_help_IakOLONlIfGI\">Cloning Notes</a>. The relation can also be inherited (e.g. from a folder holding several templates), in which case a relation owned by the template itself replaces the inherited one. The default parent is only inherited from the template's ancestors in the tree: a template created from another template does not adopt that template's default parent.</p><p>The default parent is used whenever a note is created from the template through the <em>Choose note type</em> dialog:</p><ul><li>Via <code>@</code>-completion in a&nbsp;<a class=\"reference-link\" href=\"#root/_help_iPIMuisry3hd\">Text</a>&nbsp;note</li><li>Via the <em>Create note</em> or <em>Create child note</em> options of the note search (new tab or&nbsp;<a class=\"reference-link\" href=\"#root/_help_hrZ1D00cLbal\">Internal (reference) links</a>), but only if the default/empty location is set.</li></ul><p>Creating an instance note from the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>&nbsp;context menu (<em>Insert child note</em>, <em>Insert note after</em>) still creates it at the chosen place.</p><p>Unlike the&nbsp;<a class=\"reference-link\" href=\"#root/_help_S0Fos78ZfcY7\">Note Inbox</a>, which holds quickly captured notes until they are sorted, the default parent is meant as the instances' permanent location.</p><h2>Regarding note types</h2><p>By default, newly created notes are&nbsp;<a class=\"reference-link\" href=\"#root/_help_iPIMuisry3hd\">Text</a>&nbsp;notes. If a parent note defines a <code>child:template</code> pointing to a template of a different type (e.g. a Code note), the behavior depends on how the new note is created:</p><ul><li>If no note type is explicitly chosen (e.g. the + button in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>), the template is applied and the new note takes the type and content of the template.</li><li>If a note type is explicitly selected (e.g.&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>&nbsp;→ <em>Insert note after</em> / <em>Insert child note</em>):<ul><li>If the selected type matches the template's type, the template is applied.</li><li>If the selected type differs, the template is disregarded entirely — the new note is an empty note of the selected type.</li></ul></li></ul><p>Selecting a specific template from the creation menu always takes precedence over <code>child:template</code>.</p><h2>Default title for new notes</h2><p>A template can also give its instances a default title, using the <code>#template:titleTemplate</code> label. To set it without editing the label by hand, click the template badge next to the note title and select <em>Template properties...</em>, which checks the expressions as you type and previews the resulting title. See <a class=\"reference-link\" href=\"#root/_help_47ZrP6FNuoG8\">Default Note Title</a> for details.</p><h2>Additional Notes</h2><p>From a visual perspective, templates can define <code>#iconClass</code> and <code>#cssClass</code> attributes, allowing all instance notes (e.g., books) to display a specific icon and CSS style.</p><p>Explore the concept further in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_6tZeKvSHEUiB\">Demo Notes</a>, including examples like the&nbsp;<a class=\"reference-link\" href=\"#root/_help_iRwzGnHPzonm\">Relation Map</a>,&nbsp;<a class=\"reference-link\" href=\"#root/_help_xYjQUYhpbUEW\">Task Manager</a>, and&nbsp;<a class=\"reference-link\" href=\"#root/_help_l0tKav7yLHGF\">Day Notes</a>.</p><p>Additionally, see&nbsp;<a class=\"reference-link\" href=\"#root/_help_47ZrP6FNuoG8\">Default Note Title</a>&nbsp;for creating title templates. A <code>#titleTemplate</code> on a template note is passed on to its instances like any other label, so it names the children of each instance rather than the instances themselves; to name the instances, use <code>#template:titleTemplate</code>.</p>",
"_help_B2ORr7OVEZtc": "<p>Snippets let you define reusable pieces of text, Markdown or code that can be quickly inserted into your notes.</p>",
"_help_VQjhl61rlWh9": "<p>Markdown Snippets are closely related to&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>, but instead of defining the content of an entire note, a snippet is a reusable piece of Markdown text that can easily be inserted into a&nbsp;<a class=\"reference-link\" href=\"#root/_help_6RM1Q7ppFVoj\">Markdown</a>&nbsp;note.</p><h2>Creating a Markdown snippet</h2><p>In the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>: </p><ol><li>Right-click the note where you want to place the snippet.</li><li>Select <em>Insert child note</em>.</li><li>Select <em>More</em> → <em>Markdown snippet</em>.</li></ol><p>Then simply type the desired content into the note.</p><p>The note's title becomes the title of the snippet. Optionally, you can add a description in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_OFXdgB2nNk1F\">Promoted Attributes</a>&nbsp;section.</p><h2>Inserting a snippet</h2><p>To insert a snippet, type <code>/snippet</code> and select its title from the dropdown.</p><p><a class=\"reference-link\" href=\"#root/_help_IEgsWp5hHH35\">Code Snippets</a>&nbsp;with their language mode set to \"Plain text\" are also listed here.</p><h2>Limitations</h2><ul><li>Unlike&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>, snippets cannot be limited to a particular <a href=\"#root/_help_9sRHySam5fXb\">workspace</a>.</li></ul>",
"_help_IEgsWp5hHH35": "<p>Code Snippets are closely related to&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>, but instead of defining the content of an entire note, a snippet is a reusable piece of code that can easily be inserted into a&nbsp;<a class=\"reference-link\" href=\"#root/_help_6f9hih2hXXZk\">Code</a>&nbsp;note.</p><h2>Creating a Code snippet</h2><p>In the&nbsp;<a class=\"reference-link\" href=\"#root/_help_oPVyFC7WL2Lp\">Note Tree</a>: </p><ol><li>Right-click the note where you want to place the snippet.</li><li>Select <em>Insert child note</em>.</li><li>Select <em>More</em> → <em>Code snippet</em>.</li></ol><p>Then simply type the desired code into the note and set the correct language mode.</p><p>The note's title becomes the title of the snippet. Optionally, you can add a description in the&nbsp;<a class=\"reference-link\" href=\"#root/_help_OFXdgB2nNk1F\">Promoted Attributes</a>&nbsp;section.</p><h2>Inserting a snippet</h2><p>To insert a snippet, type <code>/snippet</code> and select its title from the dropdown.</p><aside class=\"admonition important\"><p>Only code snippets whose language mode matches the current code note are listed. For example, a CSS code note shows only CSS snippets, not JavaScript ones. The exception is snippets set to \"Plain text\", which are available in&nbsp;<a class=\"reference-link\" href=\"#root/_help_6RM1Q7ppFVoj\">Markdown</a>&nbsp;notes and any code note regardless of its language mode.</p></aside><h2>Limitations</h2><ul><li>Unlike&nbsp;<a class=\"reference-link\" href=\"#root/_help_KC1HB96bqqHX\">Templates</a>, snippets cannot be limited to a particular <a href=\"#root/_help_9sRHySam5fXb\">workspace</a>.</li></ul>",
diff --git a/docs/User Guide/User Guide/Advanced Usage/Templates.md b/docs/User Guide/User Guide/Advanced Usage/Templates.md
index 127d4a1983..bae880b7f3 100644
--- a/docs/User Guide/User Guide/Advanced Usage/Templates.md
+++ b/docs/User Guide/User Guide/Advanced Usage/Templates.md
@@ -61,7 +61,7 @@ Selecting a specific template from the creation menu always takes precedence ove
## Default title for new notes
-A template can also give its instances a default title, using the `#template:titleTemplate` label. See <a class="reference-link" href="Default%20Note%20Title.md">Default Note Title</a> for details.
+A template can also give its instances a default title, using the `#template:titleTemplate` label. To set it without editing the label by hand, click the template badge next to the note title and select _Template properties..._, which checks the expressions as you type and previews the resulting title. See <a class="reference-link" href="Default%20Note%20Title.md">Default Note Title</a> for details.
## Additional Notes
diff --git a/docs/User Guide/User Guide/Basic Concepts and Features/Notes/Note badges.md b/docs/User Guide/User Guide/Basic Concepts and Features/Notes/Note badges.md
index ac25ab381d..b7ea37b11b 100644
--- a/docs/User Guide/User Guide/Basic Concepts and Features/Notes/Note badges.md
+++ b/docs/User Guide/User Guide/Basic Concepts and Features/Notes/Note badges.md
@@ -9,5 +9,5 @@ The following badges are available:
* <span class="tn-icon bx bx-share-alt"></span> **Share badge**, which will indicate that the current note is shared. The badge will also indicate if the share is on the local network (for the desktop application without <a class="reference-link" href="../../Installation%20%26%20Setup/Synchronization.md">Synchronization</a> set up) or publicly accessible (for the server).
* <span class="tn-icon bx bx-globe"></span> **Web clip badge**, which will indicate if the note was clipped using the <a class="reference-link" href="../../Installation%20%26%20Setup/Web%20Clipper.md">Web Clipper</a>. The badge acts as a link, so it can be clicked on to navigate to the page or right clicked for more options. When the clipper also saved the page's description, its author, or the dates it was published and last updated, clicking the badge shows these details instead, with a link to the page at the top.
* <span class="tn-icon bx bx-play"></span> **Execute badge**, for [scripts](../../Scripting.md) or [saved SQL queries](../../Advanced%20Usage/Database/Manually%20altering%20the%20database/SQL%20Console.md) which have an execute button or a description.
-* <span class="tn-icon bx bx-copy-alt"></span> **Template badge**, for <a class="reference-link" href="../../Advanced%20Usage/Templates.md">Templates</a> (including workspace templates, for which the badge reads _Workspace template_). Notes created from a template inherit its attributes, so the badge is a reminder that changing them affects every such note. Clicking the badge switches the template between being offered everywhere and only while hoisted into its workspace, the latter being available only for a template inside a workspace (see <a class="reference-link" href="../Navigation/Workspaces.md">Workspaces</a>).
+* <span class="tn-icon bx bx-copy-alt"></span> **Template badge**, for <a class="reference-link" href="../../Advanced%20Usage/Templates.md">Templates</a> (including workspace templates, for which the badge reads _Workspace template_). Notes created from a template inherit its attributes, so the badge is a reminder that changing them affects every such note. Clicking the badge switches the template between being offered everywhere and only while hoisted into its workspace, the latter only for a template inside a workspace (see <a class="reference-link" href="../Navigation/Workspaces.md">Workspaces</a>). It also opens _Template properties..._, where the default title of new notes is set.
* For <a class="reference-link" href="../Active%20content.md">Active content</a> (e.g. scripts, styles), a dedicated badge will be shown indicating the type of note and with an option to easily enable or disable it.
\ No newline at end of file