Argument rework

Author: mProjectsCode

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

@@ -3,12 +3,12 @@ rating: 31
 title: test title test test
 completed: false
 toggle1: true
-slider1: 7
+slider1: 63
 slider2: 5
 text1: Test text
 text_area1: Test test
 date1: 2022-05-28
-select: option c
+select: option b
 multi-select:
   - option a
   - option c
@@ -127,6 +127,7 @@ asdasd
 - `INPUT[text():meta bind/nonExistantFile#title]`
 - `INPUT[slider(nonExistantArgument)]`
 - `INPUT[select(option(option a),option(option b),option(option c),option(option d)):select]`
+
 Code block error
 ```meta-bind
 INPUT[slider(nonExistantArgument)]

exampleVault/examples.md

@@ -4,6 +4,6 @@ select: option b
 multi-select:
   - option b
   - option c
-date: Friday, October 15th 2004
+date: 2029-05-18
 time: 19:20
 ---

exampleVault/other note.md

@@ -3,8 +3,14 @@ import MetaBindPlugin from './main';
 import {Logger} from './utils/Logger';
 import {AbstractInputField} from './inputFields/AbstractInputField';
 import {InputFieldFactory} from './inputFields/InputFieldFactory';
-import {InputFieldArgument, InputFieldDeclaration, InputFieldDeclarationParser} from './parsers/InputFieldDeclarationParser';
+import {
+	InputFieldArgumentType,
+	InputFieldDeclaration,
+	InputFieldDeclarationParser
+} from './parsers/InputFieldDeclarationParser';
 import {MetaBindBindTargetError, MetaBindInternalError} from './utils/Utils';
+import {AbstractInputFieldArgument} from "./inputFieldArguments/AbstractInputFieldArgument";
+import {ClassInputFieldArgument} from "./inputFieldArguments/ClassInputFieldArgument";
 
 export enum InputFieldMarkdownRenderChildType {
 	INLINE_CODE_BLOCK,
@@ -146,15 +152,15 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 		}
 	}
 
-	getArguments(name: string): InputFieldArgument[] {
+	getArguments(name: InputFieldArgumentType): AbstractInputFieldArgument[] {
 		if (!this.inputFieldDeclaration) {
 			throw new MetaBindInternalError('inputFieldDeclaration is undefined, can not retrieve arguments');
 		}
 
-		return this.inputFieldDeclaration.arguments.filter(x => x.name === name);
+		return this.inputFieldDeclaration.argumentContainer.arguments.filter(x => x.identifier === name);
 	}
 
-	getArgument(name: string): InputFieldArgument | undefined {
+	getArgument(name: InputFieldArgumentType): AbstractInputFieldArgument | undefined {
 		return this.getArguments(name).at(0);
 	}
 
@@ -189,9 +195,9 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 
 		this.inputField.render(container);
 
-		const classArgument = this.getArguments('class');
-		if (classArgument) {
-			this.inputField.getHtmlElement().addClasses(classArgument.map(x => x.value));
+		const classArguments: ClassInputFieldArgument[] = this.getArguments(InputFieldArgumentType.CLASS);
+		if (classArguments) {
+			this.inputField.getHtmlElement().addClasses(classArguments.map(x => x.value).flat());
 		}
 
 

src/InputFieldMarkdownRenderChild.ts

@@ -0,0 +1,24 @@
+import {InputFieldArgumentType, InputFieldType} from "../parsers/InputFieldDeclarationParser";
+
+export abstract class AbstractInputFieldArgument {
+	identifier: InputFieldArgumentType = InputFieldArgumentType.INVALID;
+	allowedInputFields: InputFieldType[] = [];
+	value: any;
+	requiresValue: boolean = false;
+	allowMultiple: boolean = false;
+
+	abstract parseValue(valueStr: string): void;
+
+	isAllowed(inputFieldType: InputFieldType): boolean {
+		if (this.allowedInputFields.length === 0) {
+			return true;
+		}
+
+		return this.allowedInputFields.contains(inputFieldType);
+	}
+
+	getAllowedInputFieldsAsString() {
+		return this.allowedInputFields.length === 0 ? 'all' : this.allowedInputFields.join(', ');
+	}
+
+}

src/inputFieldArguments/AbstractInputFieldArgument.ts

@@ -0,0 +1,17 @@
+import {AbstractInputFieldArgument} from "./AbstractInputFieldArgument";
+import {InputFieldArgumentType, InputFieldType} from "../parsers/InputFieldDeclarationParser";
+
+export class AddLabelsInputFieldArgument extends AbstractInputFieldArgument {
+	identifier: InputFieldArgumentType = InputFieldArgumentType.ADD_LABELS;
+	allowedInputFields: InputFieldType[] = [
+		InputFieldType.SLIDER,
+	];
+	value: boolean = true;
+	requiresValue: boolean = false;
+	allowMultiple: boolean = false;
+
+	parseValue(valueStr: string): void {
+		this.value = (valueStr.toLowerCase() === 'true');
+	}
+
+}

src/inputFieldArguments/AddLabelsInputFieldArgument.ts

@@ -0,0 +1,14 @@
+import {AbstractInputFieldArgument} from "./AbstractInputFieldArgument";
+import {InputFieldArgumentType, InputFieldType} from "../parsers/InputFieldDeclarationParser";
+
+export class ClassInputFieldArgument extends AbstractInputFieldArgument {
+	identifier: InputFieldArgumentType = InputFieldArgumentType.CLASS;
+	allowedInputFields: InputFieldType[] = [];
+	value: string[] = [];
+	requiresValue: boolean = true;
+	allowMultiple: boolean = true;
+
+	parseValue(valueStr: string): void {
+		this.value = valueStr.split(' ');
+	}
+}

src/inputFieldArguments/ClassInputFieldArgument.ts

@@ -0,0 +1,67 @@
+import {AbstractInputFieldArgument} from "./AbstractInputFieldArgument";
+import {InputFieldArgumentType} from "../parsers/InputFieldDeclarationParser";
+import {MetaBindParsingError} from "../utils/Utils";
+
+export class InputFieldArgumentContainer {
+	arguments: AbstractInputFieldArgument[] = [];
+
+	add(argument: AbstractInputFieldArgument): void {
+		this.arguments.push(argument);
+	}
+
+	validate(): void {
+		let map: Record<string, number> = {};
+		for (const inputFieldArgumentType of Object.values(InputFieldArgumentType)) {
+			map[inputFieldArgumentType] = 0;
+		}
+
+		for (const argument of this.arguments) {
+			map[argument.identifier] += 1;
+			if (map[argument.identifier] > 1 && !argument.allowMultiple) {
+				throw new MetaBindParsingError(`argument \'${argument.identifier}\' does not allow duplicates`)
+			}
+		}
+	}
+
+	/**
+	 * Merges two InputFieldArgumentContainers by overriding.
+	 * The arguments form the other container take priority.
+	 *
+	 * @param other
+	 */
+	mergeByOverride(other: InputFieldArgumentContainer): InputFieldArgumentContainer {
+		for (const argument of other.arguments) {
+			if (!argument.allowMultiple) {
+				this.arguments = this.arguments.filter(x => x.identifier !== argument.identifier);
+			}
+			this.arguments.push(argument);
+		}
+
+		// should not be necessary but it is better to check
+		this.validate();
+
+		return this;
+	}
+
+	/**
+	 * Merges two InputFieldArgumentContainers.
+	 * If there is an argument that does not allow duplicates in both containers this will throw an error.
+	 *
+	 * @param other
+	 */
+	mergeByThrow(other: InputFieldArgumentContainer): InputFieldArgumentContainer {
+		for (const argument of other.arguments) {
+			if (!argument.allowMultiple) {
+				if (this.arguments.filter(x => x.identifier === argument.identifier).length > 0) {
+					throw new MetaBindParsingError('can not merge InputFieldArgumentContainers, since arguments overlap');
+				}
+			}
+			this.arguments.push(argument);
+		}
+
+		// should not be necessary but it is better to check
+		this.validate();
+
+		return this;
+	}
+}

src/inputFieldArguments/InputFieldArgumentContainer.ts

@@ -0,0 +1,29 @@
+import {ClassInputFieldArgument} from "./ClassInputFieldArgument";
+import {MetaBindParsingError} from "../utils/Utils";
+import {InputFieldArgumentType} from "../parsers/InputFieldDeclarationParser";
+import {AddLabelsInputFieldArgument} from "./AddLabelsInputFieldArgument";
+import {MinValueInputFieldArgument} from "./MinValueInputFieldArgument";
+import {MaxValueInputFieldArgument} from "./MaxValueInputFieldArgument";
+import {OptionInputFieldArgument} from "./OptionInputFieldArgument";
+import {TitleInputFieldArgument} from "./TitleInputFieldArgument";
+
+
+export class InputFieldArgumentFactory {
+	static createInputFieldArgument(argumentIdentifier: string) {
+		if (argumentIdentifier === InputFieldArgumentType.CLASS) {
+			return new ClassInputFieldArgument();
+		} else if (argumentIdentifier === InputFieldArgumentType.ADD_LABELS) {
+			return new AddLabelsInputFieldArgument();
+		} else if (argumentIdentifier === InputFieldArgumentType.MIN_VALUE) {
+			return new MinValueInputFieldArgument();
+		} else if (argumentIdentifier === InputFieldArgumentType.MAX_VALUE) {
+			return new MaxValueInputFieldArgument();
+		} else if (argumentIdentifier === InputFieldArgumentType.OPTION) {
+			return new OptionInputFieldArgument();
+		} else if (argumentIdentifier === InputFieldArgumentType.TITLE) {
+			return new TitleInputFieldArgument();
+		} else {
+			throw new MetaBindParsingError(`unknown argument \'${argumentIdentifier}\'`);
+		}
+	}
+}

src/inputFieldArguments/InputFieldArgumentFactory.ts

@@ -0,0 +1,21 @@
+import {AbstractInputFieldArgument} from "./AbstractInputFieldArgument";
+import {InputFieldArgumentType, InputFieldType} from "../parsers/InputFieldDeclarationParser";
+import {MetaBindParsingError} from "../utils/Utils";
+
+export class MaxValueInputFieldArgument extends AbstractInputFieldArgument {
+	identifier: InputFieldArgumentType = InputFieldArgumentType.MAX_VALUE;
+	allowedInputFields: InputFieldType[] = [
+		InputFieldType.SLIDER,
+	];
+	value: number = 100;
+	requiresValue: boolean = true;
+	allowMultiple: boolean = false;
+
+	parseValue(valueStr: string): void {
+		this.value = Number.parseInt(valueStr);
+		if (Number.isNaN(this.value)) {
+			throw new MetaBindParsingError('value of argument \'maxValue\' must be of type number');
+		}
+	}
+
+}