fix(template): scope YAML placeholders to post-processing

chhoumann · chhoumann · commit 54bb3d8498c7 · 2026-03-14T20:37:56.000+01:00
diff --git a/src/engine/CaptureChoiceEngine.selection.test.ts b/src/engine/CaptureChoiceEngine.selection.test.ts
@@ -23,6 +23,9 @@ vi.mock("../formatters/captureChoiceFormatter", () => ({
 		}
 		setDestinationFile() {}
 		setDestinationSourcePath() {}
+		async withTemplatePropertyCollection<T>(work: () => Promise<T>) {
+			return await work();
+		}
 		async formatContentOnly(content: string) {
 			return content;
 		}
diff --git a/src/engine/CaptureChoiceEngine.ts b/src/engine/CaptureChoiceEngine.ts
@@ -628,18 +628,22 @@ export class CaptureChoiceEngine extends QuickAddChoiceEngine {
 		this.formatter.setDestinationFile(file);
 
 		// First format pass...
-		const formatted = await this.formatter.formatContentOnly(content);
+		const formatted = await this.formatter.withTemplatePropertyCollection(
+			() => this.formatter.formatContentOnly(content),
+		);
 		this.mergeCapturePropertyVars(this.formatter.getAndClearTemplatePropertyVars());
 
 		const fileContent: string = await this.app.vault.read(file);
 		// Second format pass, with the file content... User input (long running) should have been captured during first pass
 		// So this pass is to insert the formatted capture value into the file content, depending on the user's settings
 		const formattedFileContent: string =
-			await this.formatter.formatContentWithFile(
-				formatted,
-				this.choice,
-				fileContent,
-				file,
+			await this.formatter.withTemplatePropertyCollection(() =>
+				this.formatter.formatContentWithFile(
+					formatted,
+					this.choice,
+					fileContent,
+					file,
+				),
 			);
 		this.mergeCapturePropertyVars(this.formatter.getAndClearTemplatePropertyVars());
 
@@ -685,7 +689,9 @@ export class CaptureChoiceEngine extends QuickAddChoiceEngine {
 		// This mirrors the logic used when the target file already exists and prevents the timing issue
 		// where templater would run before the {{value}} placeholder is substituted (Issue #809).
 		const formattedCaptureContent: string =
-			await this.formatter.formatContentOnly(captureContent);
+			await this.formatter.withTemplatePropertyCollection(() =>
+				this.formatter.formatContentOnly(captureContent),
+			);
 		this.mergeCapturePropertyVars(this.formatter.getAndClearTemplatePropertyVars());
 
 		let fileContent = "";
@@ -743,12 +749,15 @@ export class CaptureChoiceEngine extends QuickAddChoiceEngine {
 		// after the initial Templater run on newly created files.
 		const updatedFileContent: string = await this.app.vault.read(file);
 		// Second formatting pass: embed the already-resolved capture content into the newly created file
-		const newFileContent: string = await this.formatter.formatContentWithFile(
-			formattedCaptureContent,
-			this.choice,
-			updatedFileContent,
-			file,
-		);
+		const newFileContent: string =
+			await this.formatter.withTemplatePropertyCollection(() =>
+				this.formatter.formatContentWithFile(
+					formattedCaptureContent,
+					this.choice,
+					updatedFileContent,
+					file,
+				),
+			);
 		this.mergeCapturePropertyVars(this.formatter.getAndClearTemplatePropertyVars());
 
 		return { file, newFileContent, captureContent: formattedCaptureContent };
diff --git a/src/engine/SingleTemplateEngine.ts b/src/engine/SingleTemplateEngine.ts
@@ -21,8 +21,8 @@ export class SingleTemplateEngine extends TemplateEngine {
 			log.logError(`Template ${this.templatePath} not found.`);
 		}
 
-		templateContent = await this.formatter.formatFileContent(
-			templateContent
+		templateContent = await this.formatter.withTemplatePropertyCollection(
+			() => this.formatter.formatFileContent(templateContent),
 		);
 
 		return templateContent;
diff --git a/src/engine/TemplateChoiceEngine.notice.test.ts b/src/engine/TemplateChoiceEngine.notice.test.ts
@@ -66,6 +66,9 @@ vi.mock("../formatters/completeFormatter", () => {
 		async formatFileContent(...args: unknown[]) {
 			return await formatFileContentMock(...args);
 		}
+		async withTemplatePropertyCollection<T>(work: () => Promise<T>) {
+			return await work();
+		}
 		getAndClearTemplatePropertyVars() {
 			return new Map<string, unknown>();
 		}
diff --git a/src/engine/TemplateEngine.ts b/src/engine/TemplateEngine.ts
@@ -480,7 +480,9 @@ export abstract class TemplateEngine extends QuickAddEngine {
 			this.formatter.setTitle(fileBasename);
 
 			const formattedTemplateContent: string =
-				await this.formatter.formatFileContent(templateContent);
+				await this.formatter.withTemplatePropertyCollection(() =>
+					this.formatter.formatFileContent(templateContent),
+				);
 
 			// Get template variables before creating the file
 			const templateVars = this.formatter.getAndClearTemplatePropertyVars();
@@ -537,7 +539,9 @@ export abstract class TemplateEngine extends QuickAddEngine {
 			this.formatter.setTitle(fileBasename);
 
 			const formattedTemplateContent: string =
-				await this.formatter.formatFileContent(templateContent);
+				await this.formatter.withTemplatePropertyCollection(() =>
+					this.formatter.formatFileContent(templateContent),
+				);
 
 			// Get template variables before modifying the file
 			const templateVars = this.formatter.getAndClearTemplatePropertyVars();
diff --git a/src/engine/templateEngine-title.test.ts b/src/engine/templateEngine-title.test.ts
@@ -12,6 +12,9 @@ vi.mock('../formatters/completeFormatter', () => {
             return {
                 setTitle: vi.fn((t: string) => { title = t; }),
                 getTitle: () => title,
+                withTemplatePropertyCollection: vi.fn(
+                    async (work: () => Promise<unknown>) => await work(),
+                ),
                 formatFileContent: vi.fn(async (content: string) => {
                     // Simple mock that replaces {{title}} with the stored title
                     return content.replace(/{{title}}/gi, title);
diff --git a/src/formatters/formatter-template-property-types.test.ts b/src/formatters/formatter-template-property-types.test.ts
@@ -24,8 +24,7 @@ class TemplatePropertyTypesTestFormatter extends Formatter {
 	}
 
 	protected getVariableValue(variableName: string): string {
-		const value = this.variables.get(variableName);
-		return typeof value === 'string' ? value : '';
+		return (this.variables.get(variableName) as string) ?? '';
 	}
 
 	protected suggestForValue(
@@ -85,6 +84,14 @@ class TemplatePropertyTypesTestFormatter extends Formatter {
 	public async testFormat(input: string): Promise<string> {
 		return await this.format(input);
 	}
+
+	public async testFormatWithTemplatePropertyCollection(
+		input: string,
+	): Promise<string> {
+		return await this.withTemplatePropertyCollection(() =>
+			this.testFormat(input),
+		);
+	}
 }
 
 describe('Formatter template property type inference', () => {
@@ -110,37 +117,68 @@ describe('Formatter template property type inference', () => {
 
 	it('collects comma-separated values as YAML arrays', async () => {
 		(formatter as any).variables.set('tags', 'tag1, tag2, awesomeproject');
-		await formatter.testFormat('---\ntags: {{VALUE:tags}}\n---');
+		await formatter.testFormatWithTemplatePropertyCollection(
+			'---\ntags: {{VALUE:tags}}\n---',
+		);
 		const vars = formatter.getAndClearTemplatePropertyVars();
 		expect(vars.get('tags')).toEqual(['tag1', 'tag2', 'awesomeproject']);
 	});
 
 	it('does not collect comma text for scalar properties', async () => {
 		(formatter as any).variables.set('description', 'Hello, world');
-		await formatter.testFormat('---\ndescription: {{VALUE:description}}\n---');
+		await formatter.testFormatWithTemplatePropertyCollection(
+			'---\ndescription: {{VALUE:description}}\n---',
+		);
 		const vars = formatter.getAndClearTemplatePropertyVars();
 		expect(vars.has('description')).toBe(false);
 	});
 
 	it('collects bullet list values as YAML arrays', async () => {
 		(formatter as any).variables.set('projects', '- project1\n- project2');
-		await formatter.testFormat('---\nprojects: {{VALUE:projects}}\n---');
+		await formatter.testFormatWithTemplatePropertyCollection(
+			'---\nprojects: {{VALUE:projects}}\n---',
+		);
 		const vars = formatter.getAndClearTemplatePropertyVars();
 		expect(vars.get('projects')).toEqual(['project1', 'project2']);
 	});
 
-	it('uses a YAML-safe placeholder for collected arrays before post-processing', async () => {
+	it('preserves raw structured replacements outside template property collection', async () => {
 		(formatter as any).variables.set('tags', ['[[John Doe]]', '[[Jane Doe]]']);
 		const output = await formatter.testFormat('---\ntags: {{VALUE:tags}}\n---');
 		const vars = formatter.getAndClearTemplatePropertyVars();
 
+		expect(output).toBe('---\ntags: [[John Doe]],[[Jane Doe]]\n---');
+		expect(vars.size).toBe(0);
+	});
+
+	it('uses a YAML-safe placeholder for collected arrays before post-processing', async () => {
+		(formatter as any).variables.set('tags', ['[[John Doe]]', '[[Jane Doe]]']);
+		const output = await formatter.testFormatWithTemplatePropertyCollection(
+			'---\ntags: {{VALUE:tags}}\n---',
+		);
+		const vars = formatter.getAndClearTemplatePropertyVars();
+
 		expect(output).toBe('---\ntags: []\n---');
 		expect(vars.get('tags')).toEqual(['[[John Doe]]', '[[Jane Doe]]']);
 	});
 
+	it('does not apply case transforms to YAML placeholders', async () => {
+		(formatter as any).variables.set('done', null);
+		const output =
+			await formatter.testFormatWithTemplatePropertyCollection(
+				'---\ndone: {{VALUE:done|case:upper}}\n---',
+			);
+		const vars = formatter.getAndClearTemplatePropertyVars();
+
+		expect(output).toBe('---\ndone: null\n---');
+		expect(vars.get('done')).toBeNull();
+	});
+
 	it('ignores wiki links with commas to avoid incorrect splitting', async () => {
 		(formatter as any).variables.set('source', '[[test, a]]');
-		await formatter.testFormat('---\nsource: {{VALUE:source}}\n---');
+		await formatter.testFormatWithTemplatePropertyCollection(
+			'---\nsource: {{VALUE:source}}\n---',
+		);
 		const vars = formatter.getAndClearTemplatePropertyVars();
 		expect(vars.has('source')).toBe(false);
 	});
diff --git a/src/formatters/formatter.ts b/src/formatters/formatter.ts
@@ -59,6 +59,7 @@ export abstract class Formatter {
 
 	// Tracks variables collected for YAML property post-processing
 	private readonly propertyCollector: TemplatePropertyCollector;
+	private templatePropertyCollectionDepth = 0;
 
 	protected constructor(protected readonly app?: App) {
 		this.propertyCollector = new TemplatePropertyCollector(app);
@@ -303,6 +304,23 @@ export abstract class Formatter {
 		return this.propertyCollector.drain();
 	}
 
+	/**
+	 * Runs a formatting operation in a scope where structured YAML values should
+	 * be collected and replaced with temporary placeholders for later
+	 * `processFrontMatter()` post-processing.
+	 */
+	public async withTemplatePropertyCollection<T>(
+		work: () => Promise<T>,
+	): Promise<T> {
+		this.templatePropertyCollectionDepth += 1;
+
+		try {
+			return await work();
+		} finally {
+			this.templatePropertyCollectionDepth -= 1;
+		}
+	}
+
 	protected abstract getCurrentFileLink(): string | null;
 	protected abstract getCurrentFileName(): string | null;
 
@@ -393,15 +411,16 @@ export abstract class Formatter {
 				matchEnd: match.index + match[0].length,
 				rawValue: rawValueForCollector,
 				fallbackKey: variableName,
-				featureEnabled: propertyTypesEnabled,
+				featureEnabled:
+					propertyTypesEnabled &&
+					this.templatePropertyCollectionDepth > 0,
 			});
 
 			// Keep the interim frontmatter YAML-parseable until post-processing
 			// writes the real structured value back through Obsidian.
-			const rawReplacement =
-				getYamlPlaceholder(structuredYamlValue) ??
-				this.getVariableValue(effectiveKey);
-			const replacement = transformCase(rawReplacement, caseStyle);
+			const placeholder = getYamlPlaceholder(structuredYamlValue);
+			const replacement = placeholder ??
+				transformCase(this.getVariableValue(effectiveKey), caseStyle);
 
 			// Replace in output and adjust regex position
 			output = output.slice(0, match.index) + replacement + output.slice(match.index + match[0].length);
diff --git a/tests/e2e/template-property-links.test.ts b/tests/e2e/template-property-links.test.ts

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,9 @@ vi.mock("../formatters/captureChoiceFormatter", () => ({`
`23`	`23`	`}`
`24`	`24`	`setDestinationFile() {}`
`25`	`25`	`setDestinationSourcePath() {}`
	`26`	`+ async withTemplatePropertyCollection<T>(work: () => Promise<T>) {`
	`27`	`+ return await work();`
	`28`	`+ }`
`26`	`29`	`async formatContentOnly(content: string) {`
`27`	`30`	`return content;`
`28`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,8 @@ export class SingleTemplateEngine extends TemplateEngine {`
`21`	`21`	log.logError(`Template ${this.templatePath} not found.`);
`22`	`22`	`}`
`23`	`23`
`24`		`- templateContent = await this.formatter.formatFileContent(`
`25`		`- templateContent`
	`24`	`+ templateContent = await this.formatter.withTemplatePropertyCollection(`
	`25`	`+ () => this.formatter.formatFileContent(templateContent),`
`26`	`26`	`);`
`27`	`27`
`28`	`28`	`return templateContent;`
Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,9 @@ vi.mock("../formatters/completeFormatter", () => {`
`66`	`66`	`async formatFileContent(...args: unknown[]) {`
`67`	`67`	`return await formatFileContentMock(...args);`
`68`	`68`	`}`
	`69`	`+ async withTemplatePropertyCollection<T>(work: () => Promise<T>) {`
	`70`	`+ return await work();`
	`71`	`+ }`
`69`	`72`	`getAndClearTemplatePropertyVars() {`
`70`	`73`	`return new Map<string, unknown>();`
`71`	`74`	`}`