feat: support .base template files for template choices

Author: chhoumann

docs/docs/Choices/TemplateChoice.md

@@ -7,7 +7,7 @@ The template choice type is not meant to be a replacement for [Templater](https:
 ## Mandatory
 **Template Path**. This is a path to the template you wish to insert. Paths are vault-relative; a leading `/` is ignored.
 
-QuickAdd supports both markdown (`.md`) and canvas (`.canvas`) templates. When using a canvas template, the created file will also be a canvas file with the same extension.
+QuickAdd supports markdown (`.md`), canvas (`.canvas`), and base (`.base`) templates. The created file uses the same extension as the template.
 
 ## Optional
 **File Name Format**. You can specify a format for the file name, which is based on the format syntax - which you can see further down this page.

src/constants.ts

@@ -98,9 +98,12 @@ export const LINK_TO_CURRENT_FILE_REGEX = new RegExp(/{{LINKCURRENT}}/i);
 export const FILE_NAME_OF_CURRENT_FILE_REGEX = new RegExp(/{{FILENAMECURRENT}}/i);
 export const MARKDOWN_FILE_EXTENSION_REGEX = new RegExp(/\.md$/);
 export const CANVAS_FILE_EXTENSION_REGEX = new RegExp(/\.canvas$/);
+export const BASE_FILE_EXTENSION_REGEX = new RegExp(/\.base$/);
 export const JAVASCRIPT_FILE_EXTENSION_REGEX = new RegExp(/\.js$/);
 export const MACRO_REGEX = new RegExp(/{{MACRO:([^\n\r}]*)}}/i);
-export const TEMPLATE_REGEX = new RegExp(/{{TEMPLATE:([^\n\r}]*.md)}}/i);
+export const TEMPLATE_REGEX = new RegExp(
+	/{{TEMPLATE:([^\n\r}]*\.(?:md|canvas|base))}}/i,
+);
 export const GLOBAL_VAR_REGEX = new RegExp(/{{GLOBAL_VAR:([^\n\r}]*)}}/i);
 export const INLINE_JAVASCRIPT_REGEX = new RegExp(
 	/`{3,}js quickadd([\s\S]*?)`{3,}/,

src/engine/TemplateChoiceEngine.notice.test.ts

@@ -332,6 +332,50 @@ describe("TemplateChoiceEngine file casing resolution", () => {
 			engine.choice.templatePath,
 		);
 	});
+
+	it("supports existing .base files for overwrite mode", async () => {
+		const { engine, app } = createEngine("ignored", {
+			throwDuringFileName: false,
+			stubTemplateContent: true,
+		});
+
+		const existingFile = new TFile();
+		existingFile.path = "Board.base";
+		existingFile.name = "Board.base";
+		existingFile.extension = "base";
+		existingFile.basename = "Board";
+
+		engine.choice.templatePath = "Templates/Board.base";
+		engine.choice.fileExistsMode = fileExistsOverwriteFile;
+		engine.choice.setFileExistsBehavior = true;
+		formatFileNameMock.mockResolvedValueOnce("Board");
+
+		(app.vault.adapter.exists as ReturnType<typeof vi.fn>).mockResolvedValue(
+			true,
+		);
+		(app.vault.getAbstractFileByPath as ReturnType<typeof vi.fn>).mockReturnValue(
+			existingFile,
+		);
+
+		const overwriteSpy = vi
+			.spyOn(
+				engine as unknown as {
+					overwriteFileWithTemplate: (
+						file: TFile,
+						templatePath: string,
+					) => Promise<TFile | null>;
+				},
+				"overwriteFileWithTemplate",
+			)
+			.mockResolvedValue(existingFile);
+
+		await engine.run();
+
+		expect(overwriteSpy).toHaveBeenCalledWith(
+			existingFile,
+			"Templates/Board.base",
+		);
+	});
 });
 
 describe("TemplateChoiceEngine destination path resolution", () => {

src/engine/TemplateChoiceEngine.ts

@@ -105,10 +105,12 @@ export class TemplateChoiceEngine extends TemplateEngine {
 				const file = this.findExistingFile(filePath);
 				if (
 					!(file instanceof TFile) ||
-					(file.extension !== "md" && file.extension !== "canvas")
+					(file.extension !== "md" &&
+						file.extension !== "canvas" &&
+						file.extension !== "base")
 				) {
 					log.logError(
-						`'${filePath}' already exists but could not be resolved as a markdown or canvas file.`,
+						`'${filePath}' already exists but could not be resolved as a markdown, canvas, or base file.`,
 					);
 					return;
 				}

src/engine/TemplateEngine.ts

@@ -11,7 +11,11 @@ import {
 } from "../utilityObsidian";
 import GenericSuggester from "../gui/GenericSuggester/genericSuggester";
 import InputSuggester from "../gui/InputSuggester/inputSuggester";
-import { MARKDOWN_FILE_EXTENSION_REGEX, CANVAS_FILE_EXTENSION_REGEX } from "../constants";
+import {
+	BASE_FILE_EXTENSION_REGEX,
+	CANVAS_FILE_EXTENSION_REGEX,
+	MARKDOWN_FILE_EXTENSION_REGEX,
+} from "../constants";
 import { reportError } from "../utils/errorUtils";
 import { basenameWithoutMdOrCanvas } from "../utils/pathUtils";
 import {
@@ -441,6 +445,9 @@ export abstract class TemplateEngine extends QuickAddEngine {
 		if (CANVAS_FILE_EXTENSION_REGEX.test(templatePath)) {
 			return ".canvas";
 		}
+		if (BASE_FILE_EXTENSION_REGEX.test(templatePath)) {
+			return ".base";
+		}
 		return ".md";
 	}
 
@@ -454,7 +461,8 @@ export abstract class TemplateEngine extends QuickAddEngine {
 		const extension = this.getTemplateExtension(templatePath);
 		const formattedFileName: string = this.stripLeadingSlash(fileName)
 			.replace(MARKDOWN_FILE_EXTENSION_REGEX, "")
-			.replace(CANVAS_FILE_EXTENSION_REGEX, "");
+			.replace(CANVAS_FILE_EXTENSION_REGEX, "")
+			.replace(BASE_FILE_EXTENSION_REGEX, "");
 		return `${actualFolderPath}${formattedFileName}${extension}`;
 	}
 
@@ -463,7 +471,12 @@ export abstract class TemplateEngine extends QuickAddEngine {
 		let newFileName = fileName;
 
 		// Determine the extension from the filename and construct a matching regex
-		const extension = CANVAS_FILE_EXTENSION_REGEX.test(fileName) ? ".canvas" : ".md";
+		let extension = ".md";
+		if (CANVAS_FILE_EXTENSION_REGEX.test(fileName)) {
+			extension = ".canvas";
+		} else if (BASE_FILE_EXTENSION_REGEX.test(fileName)) {
+			extension = ".base";
+		}
 		const extPattern = extension.replace(/\./g, "\\.");
 		const numberWithExtRegex = new RegExp(`(\\d*)${extPattern}$`);
 		const exec = numberWithExtRegex.exec(fileName);
@@ -501,8 +514,8 @@ export abstract class TemplateEngine extends QuickAddEngine {
 				templatePath
 			);
 
-				// Extract filename without extension from the full path (supports .md and .canvas)
-				const fileBasename = basenameWithoutMdOrCanvas(filePath);
+			// Extract filename without extension from the full path.
+			const fileBasename = basenameWithoutMdOrCanvas(filePath);
 			this.formatter.setTitle(fileBasename);
 
 			const formattedTemplateContent: string =
@@ -636,7 +649,8 @@ export abstract class TemplateEngine extends QuickAddEngine {
 	protected async getTemplateContent(templatePath: string): Promise<string> {
 		let correctTemplatePath: string = this.stripLeadingSlash(templatePath);
 		if (!MARKDOWN_FILE_EXTENSION_REGEX.test(templatePath) && 
-			!CANVAS_FILE_EXTENSION_REGEX.test(templatePath))
+			!CANVAS_FILE_EXTENSION_REGEX.test(templatePath) &&
+			!BASE_FILE_EXTENSION_REGEX.test(templatePath))
 			correctTemplatePath += ".md";
 
 		const templateFile =

src/engine/canvas-integration.test.ts

@@ -5,6 +5,7 @@ describe('Canvas Template Integration', () => {
 		// Test the actual regex patterns used in the implementation
 		const MARKDOWN_REGEX = new RegExp(/\.md$/);
 		const CANVAS_REGEX = new RegExp(/\.canvas$/);
+		const BASE_REGEX = new RegExp(/\.base$/);
 
 		it('should correctly identify markdown files', () => {
 			expect(MARKDOWN_REGEX.test('file.md')).toBe(true);
@@ -21,22 +22,29 @@ describe('Canvas Template Integration', () => {
 		});
 
 		it('should have mutually exclusive patterns', () => {
-			const testFiles = ['file.md', 'file.canvas', 'file.txt', 'file'];
+			const testFiles = ['file.md', 'file.canvas', 'file.base', 'file.txt', 'file'];
 
 			testFiles.forEach(file => {
 				const matchesMd = MARKDOWN_REGEX.test(file);
 				const matchesCanvas = CANVAS_REGEX.test(file);
+				const matchesBase = BASE_REGEX.test(file);
 				expect(matchesMd && matchesCanvas).toBe(false);
+				expect(matchesMd && matchesBase).toBe(false);
+				expect(matchesCanvas && matchesBase).toBe(false);
 			});
 		});
 	});
 
 	describe('Template extension logic', () => {
 		const getTemplateExtension = (templatePath: string): string => {
 			const CANVAS_REGEX = new RegExp(/\.canvas$/);
+			const BASE_REGEX = new RegExp(/\.base$/);
 			if (CANVAS_REGEX.test(templatePath)) {
 				return ".canvas";
 			}
+			if (BASE_REGEX.test(templatePath)) {
+				return ".base";
+			}
 			return ".md";
 		};
 
@@ -50,6 +58,11 @@ describe('Canvas Template Integration', () => {
 			expect(getTemplateExtension('template')).toBe('.md');
 			expect(getTemplateExtension('template.txt')).toBe('.md');
 		});
+
+		it('should return .base for base templates', () => {
+			expect(getTemplateExtension('template.base')).toBe('.base');
+			expect(getTemplateExtension('path/to/template.base')).toBe('.base');
+		});
 	});
 
 	describe('File path normalization', () => {
@@ -64,13 +77,20 @@ describe('Canvas Template Integration', () => {
 		): string => {
 			const MARKDOWN_REGEX = new RegExp(/\.md$/);
 			const CANVAS_REGEX = new RegExp(/\.canvas$/);
+			const BASE_REGEX = new RegExp(/\.base$/);
 
 			const safeFolderPath = stripLeadingSlash(folderPath);
 			const actualFolderPath = safeFolderPath ? `${safeFolderPath}/` : "";
-			const extension = CANVAS_REGEX.test(templatePath) ? ".canvas" : ".md";
+			let extension = ".md";
+			if (CANVAS_REGEX.test(templatePath)) {
+				extension = ".canvas";
+			} else if (BASE_REGEX.test(templatePath)) {
+				extension = ".base";
+			}
 			const formattedFileName = stripLeadingSlash(fileName)
 				.replace(MARKDOWN_REGEX, "")
-				.replace(CANVAS_REGEX, "");
+				.replace(CANVAS_REGEX, "")
+				.replace(BASE_REGEX, "");
 			return `${actualFolderPath}${formattedFileName}${extension}`;
 		};
 
@@ -98,18 +118,27 @@ describe('Canvas Template Integration', () => {
 			expect(normalizeTemplateFilePath('/Templates', '/MyFile', 'template.md'))
 				.toBe('Templates/MyFile.md');
 		});
+
+		it('should create base paths for base templates', () => {
+			expect(normalizeTemplateFilePath('Templates', 'Board', 'template.base'))
+				.toBe('Templates/Board.base');
+		});
 	});
 
 	describe('Template path processing logic', () => {
 		const shouldAppendMdExtension = (templatePath: string): boolean => {
 			const MARKDOWN_REGEX = new RegExp(/\.md$/);
 			const CANVAS_REGEX = new RegExp(/\.canvas$/);
-			return !MARKDOWN_REGEX.test(templatePath) && !CANVAS_REGEX.test(templatePath);
+			const BASE_REGEX = new RegExp(/\.base$/);
+			return !MARKDOWN_REGEX.test(templatePath) &&
+				!CANVAS_REGEX.test(templatePath) &&
+				!BASE_REGEX.test(templatePath);
 		};
 
 		it('should not append .md to recognized extensions', () => {
 			expect(shouldAppendMdExtension('template.canvas')).toBe(false);
 			expect(shouldAppendMdExtension('template.md')).toBe(false);
+			expect(shouldAppendMdExtension('template.base')).toBe(false);
 		});
 
 		it('should append .md to unrecognized paths', () => {
@@ -120,12 +149,13 @@ describe('Canvas Template Integration', () => {
 
 	describe('File validation logic', () => {
 		const isValidFileType = (extension: string): boolean => {
-			return extension === 'md' || extension === 'canvas';
+			return extension === 'md' || extension === 'canvas' || extension === 'base';
 		};
 
 		it('should accept markdown and canvas files', () => {
 			expect(isValidFileType('md')).toBe(true);
 			expect(isValidFileType('canvas')).toBe(true);
+			expect(isValidFileType('base')).toBe(true);
 		});
 
 		it('should reject other file types', () => {

src/engine/templateEngine-increment-canvas.test.ts

@@ -85,4 +85,12 @@ describe('TemplateEngine - incrementFileName for .canvas', () => {
     const out = await engine.testIncrement('Doc.md');
     expect(out).toBe('Doc1.md');
   });
+
+  it('works similarly for .base', async () => {
+    (mockApp.vault.adapter.exists as any)
+      .mockResolvedValueOnce(true)  // Board.base exists
+      .mockResolvedValueOnce(false);
+    const out = await engine.testIncrement('Board.base');
+    expect(out).toBe('Board1.base');
+  });
 });

src/engine/templateEngine-title.test.ts

@@ -125,6 +125,11 @@ describe('TemplateEngine - Title Handling', () => {
             expect(engine.getFormatterTitle()).toBe('CanvasDoc');
         });
 
+        it('should extract title from .base filename', async () => {
+            await engine.testCreateFileWithTemplate('folder/Kanban.base', 'template.base');
+            expect(engine.getFormatterTitle()).toBe('Kanban');
+        });
+
         it('should format content with title replacement', async () => {
             const mockFormatter = (engine as any).formatter;
 

src/preflight/RequirementCollector.test.ts

@@ -95,6 +95,15 @@ describe("RequirementCollector", () => {
     expect(rc.templatesToScan.size === 0 || rc.templatesToScan.has("Templates/Note")).toBe(true);
   });
 
+  it("records .base TEMPLATE references for recursive scanning", async () => {
+    const app = makeApp();
+    const plugin = makePlugin();
+    const rc = new RequirementCollector(app, plugin);
+    await rc.scanString("{{TEMPLATE:Templates/Kanban.base}}" );
+
+    expect(rc.templatesToScan.has("Templates/Kanban.base")).toBe(true);
+  });
+
   it("uses textarea for VALUE tokens with type:multiline", async () => {
     const app = makeApp();
     const plugin = makePlugin({ inputPrompt: "single-line" });