templates finished

Author: mProjectsCode

exampleVault/.obsidian/plugins/obsidian-meta-bind-plugin/main.js

@@ -2,8 +2,8 @@
 rating: 31
 title: test title test test
 completed: false
-toggle1: true
-slider1: 63
+toggle1: false
+slider1: 5
 slider2: 5
 text1: Test text
 text_area1: Test test
@@ -123,6 +123,12 @@ Lorem ipsum dolor sit amet, `INPUT[date():other note#date]` consectetur adipisci
 
 asdasd
 
+## Templates
+- unknown tempalate
+	- `INPUT[][toggle:toggle1]`
+	- `INPUT[nonExistantTemplate][toggle:toggle1]`
+- `INPUT[toggleTemplate][:toggle1]`
+
 ## Error Messages
 - `INPUT[text():meta bind/nonExistantFile#title]`
 - `INPUT[slider(nonExistantArgument)]`

exampleVault/examples.md

@@ -4,6 +4,6 @@ select: option b
 multi-select:
   - option b
   - option c
-date: 2029-05-18
+date: 2029-05-11
 time: 19:20
 ---

exampleVault/other note.md

@@ -14,7 +14,7 @@
 	"license": "MIT",
 	"devDependencies": {
 		"@tsconfig/svelte": "^3.0.0",
-		"@types/jest": "^28.1.3",
+		"@types/jest": "^28.1.6",
 		"@types/node": "^16.11.6",
 		"@typescript-eslint/eslint-plugin": "^5.30.0",
 		"@typescript-eslint/parser": "^5.30.0",

package-lock.json

@@ -66,7 +66,7 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 			this.limitInterval = window.setInterval(() => this.applyValueQueueToMetadata(), this.plugin.settings.syncInterval);
 		} catch (e: any) {
 			this.error = e.message;
-			Logger.logWarning(e);
+			console.warn(e);
 		}
 	}
 

package.json

@@ -4,6 +4,7 @@ import {InputFieldMarkdownRenderChild, InputFieldMarkdownRenderChildType} from '
 import {getFileName, isPath, removeFileEnding} from './utils/Utils';
 import {Logger} from './utils/Logger';
 import {DateParser} from './parsers/DateParser';
+import {InputFieldDeclarationParser} from "./parsers/InputFieldDeclarationParser";
 
 export default class MetaBindPlugin extends Plugin {
 	// @ts-ignore defined in `onload`
@@ -19,6 +20,7 @@ export default class MetaBindPlugin extends Plugin {
 
 		Logger.devMode = this.settings.devMode;
 		DateParser.dateFormat = this.settings.preferredDateFormat;
+		InputFieldDeclarationParser.parseTemplates(this.settings.inputTemplates);
 
 		this.activeMarkdownInputFields = [];
 		this.markDownInputFieldIndex = 0;
@@ -194,6 +196,7 @@ export default class MetaBindPlugin extends Plugin {
 	async saveSettings(): Promise<void> {
 		DateParser.dateFormat = this.settings.preferredDateFormat;
 		Logger.devMode = this.settings.devMode;
+		InputFieldDeclarationParser.parseTemplates(this.settings.inputTemplates);
 		await this.saveData(this.settings);
 	}
 }

src/InputFieldMarkdownRenderChild.ts

@@ -38,6 +38,11 @@ export interface InputFieldDeclaration {
 	argumentContainer: InputFieldArgumentContainer;
 }
 
+export interface Template {
+	identifier: string;
+	template: InputFieldDeclaration;
+}
+
 export class InputFieldDeclarationParser {
 	static roundBracesPair: EnclosingPair = new EnclosingPair('(', ')');
 	static squareBracesPair: EnclosingPair = new EnclosingPair('[', ']');
@@ -48,15 +53,29 @@ export class InputFieldDeclarationParser {
 		InputFieldDeclarationParser.curlyBracesPair,
 	];
 
-	static templates: Record<string, InputFieldDeclaration> = {};
+	static templates: Template[] = [];
 
 
-	static parse(fullDeclaration: string, templateName?: string): InputFieldDeclaration {
+	static parse(fullDeclaration: string): InputFieldDeclaration {
 		let inputFieldDeclaration: InputFieldDeclaration = {} as InputFieldDeclaration;
 
+		let useTemplate = false;
+		let templateName = '';
+
 		// declaration
 		inputFieldDeclaration.fullDeclaration = fullDeclaration;
-		inputFieldDeclaration.declaration = ParserUtils.getInBetween(fullDeclaration, InputFieldDeclarationParser.squareBracesPair) as string;
+		const temp = ParserUtils.getInBetween(fullDeclaration, InputFieldDeclarationParser.squareBracesPair);
+		if (Array.isArray(temp)) {
+			if (temp.length === 2) {
+				useTemplate = true;
+				templateName = temp[0];
+				inputFieldDeclaration.declaration = temp[1];
+			} else {
+				throw new MetaBindParsingError('invalid input field declaration');
+			}
+		} else {
+			inputFieldDeclaration.declaration = temp;
+		}
 
 		// declaration parts
 		const declarationParts: string[] = ParserUtils.split(inputFieldDeclaration.declaration, ':', InputFieldDeclarationParser.squareBracesPair);
@@ -67,51 +86,65 @@ export class InputFieldDeclarationParser {
 
 		// input field type and arguments
 		const inputFieldTypeWithArguments: string = declarationParts[0];
-		// input field type
-		const inputFieldTypeString = ParserUtils.removeInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair);
-		inputFieldDeclaration.inputFieldType = InputFieldDeclarationParser.getInputFieldType(inputFieldTypeString);
-
-		// arguments
-		const inputFieldArgumentsString: string = ParserUtils.getInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair) as string;
-		// console.log(inputFieldArgumentsString);
-		if (inputFieldArgumentsString) {
-			inputFieldDeclaration.argumentContainer = InputFieldDeclarationParser.parseArguments(inputFieldArgumentsString, inputFieldDeclaration.inputFieldType);
+		if (inputFieldTypeWithArguments) {
+			// input field type
+			const inputFieldTypeString = ParserUtils.removeInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair);
+			inputFieldDeclaration.inputFieldType = InputFieldDeclarationParser.getInputFieldType(inputFieldTypeString);
+
+			// arguments
+			const inputFieldArgumentsString: string = ParserUtils.getInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair) as string;
+			// console.log(inputFieldArgumentsString);
+			if (inputFieldArgumentsString) {
+				inputFieldDeclaration.argumentContainer = InputFieldDeclarationParser.parseArguments(inputFieldArgumentsString, inputFieldDeclaration.inputFieldType);
+			} else {
+				inputFieldDeclaration.argumentContainer = new InputFieldArgumentContainer();
+			}
 		} else {
+			inputFieldDeclaration.inputFieldType = InputFieldType.INVALID;
 			inputFieldDeclaration.argumentContainer = new InputFieldArgumentContainer();
 		}
 
 
-		if (templateName) {
-			const template = InputFieldDeclarationParser.templates[templateName];
+		if (useTemplate) {
+			console.log(templateName);
+			const template = InputFieldDeclarationParser.templates.filter(x => x.identifier === templateName).first()?.template;
+			console.log(template);
 			if (template) {
 				inputFieldDeclaration.bindTarget = inputFieldDeclaration.bindTarget || template.bindTarget;
 				inputFieldDeclaration.isBound = inputFieldDeclaration.isBound || template.isBound;
 				inputFieldDeclaration.inputFieldType = inputFieldDeclaration.inputFieldType === InputFieldType.INVALID ? template.inputFieldType : (inputFieldDeclaration.inputFieldType || template.inputFieldType);
 				inputFieldDeclaration.argumentContainer = template.argumentContainer.mergeByOverride(inputFieldDeclaration.argumentContainer);
+			} else {
+				throw new MetaBindParsingError(`unknown template name \'${templateName}\'`);
 			}
 		}
 
 		if (inputFieldDeclaration.inputFieldType === InputFieldType.INVALID) {
-			throw new MetaBindParsingError(`unknown input field type \'${inputFieldTypeString}\'`);
+			throw new MetaBindParsingError(`unknown input field type`);
 		}
 
 		return inputFieldDeclaration;
 	}
 
 	static parseTemplates(templates: string): void {
 		let templateDeclarations = ParserUtils.split(templates, '\n', InputFieldDeclarationParser.squareBracesPair);
-		templateDeclarations.map(x => x.trim()).filter(x => x.length > 0);
+		templateDeclarations = templateDeclarations.map(x => x.trim()).filter(x => x.length > 0);
 
 		for (const templateDeclaration of templateDeclarations) {
-			const templateDeclarationParts: string[] = ParserUtils.split(templateDeclaration, '->', InputFieldDeclarationParser.squareBracesPair);
-			templateDeclarationParts.map(x => x.trim());
+			let templateDeclarationParts: string[] = ParserUtils.split(templateDeclaration, '->', InputFieldDeclarationParser.squareBracesPair);
+			templateDeclarationParts = templateDeclarationParts.map(x => x.trim());
 
 			if (templateDeclarationParts.length === 1) {
 				throw new MetaBindParsingError('Invalid template syntax');
 			} else if (templateDeclarationParts.length === 2) {
-				InputFieldDeclarationParser.templates[templateDeclarationParts[0]] = InputFieldDeclarationParser.parse(templateDeclarationParts[1]);
+				InputFieldDeclarationParser.templates.push({
+					identifier: templateDeclarationParts[0],
+					template: InputFieldDeclarationParser.parse(templateDeclarationParts[1]),
+				})
 			}
 		}
+
+		console.log(InputFieldDeclarationParser.templates);
 	}
 
 	static parseArguments(inputFieldArgumentsString: string, inputFieldType: InputFieldType): InputFieldArgumentContainer {

src/main.ts

@@ -1,4 +1,4 @@
-import {App, PluginSettingTab, Setting} from 'obsidian';
+import {App, PluginSettingTab, Setting, TextAreaComponent} from 'obsidian';
 import MetaBindPlugin from '../main';
 
 export interface MetaBindPluginSettings {
@@ -82,15 +82,17 @@ export class MetaBindSettingTab extends PluginSettingTab {
 
 		new Setting(containerEl)
 			.setName('Templates')
-			.setDesc(`You can specify templates here, and access them using \`TEMPLATE_INPUT[...]\` in your notes.`)
-			.addTextArea(cb => {
-				cb.setValue(this.plugin.settings.inputTemplates);
-				cb.setPlaceholder('template_name -> INPUT[input_type(argument(value)):bind_target]');
-				cb.onChange(data => {
-					this.plugin.settings.inputTemplates = data;
-					this.plugin.saveSettings();
-				});
-			});
+			.setDesc(`You can specify templates here, and access them using \`TEMPLATE_INPUT[...]\` in your notes.`);
+
+		const ta = new TextAreaComponent(containerEl);
+		ta.setValue(this.plugin.settings.inputTemplates);
+		ta.setPlaceholder('template_name -> INPUT[input_type(argument(value)):bind_target]');
+		ta.inputEl.style.width = '100%';
+		ta.inputEl.style.height = '200px';
+		ta.onChange(data => {
+			this.plugin.settings.inputTemplates = data;
+			this.plugin.saveSettings();
+		});
 
 
 		new Setting(containerEl)

src/parsers/InputFieldDeclarationParser.ts

@@ -31,6 +31,15 @@ export class Logger {
 		console.warn(this.prefix, data);
 	}
 
+	/**
+	 * Logs a warning to the console without the plugin prefix
+	 *
+	 * @param data
+	 */
+	static warn(...data: any): void {
+		console.warn(data);
+	}
+
 	/**
 	 * Logs an error to the console with the plugin prefix
 	 *