update and rename some stuff

Author: mProjectsCode

.prettierignore

@@ -2,3 +2,4 @@
 node_modules
 package-lock.json
 exampleVault
+main.js

src/InputFieldMarkdownRenderChild.ts

@@ -3,7 +3,7 @@ import MetaBindPlugin from './main';
 import { AbstractInputField } from './inputFields/AbstractInputField';
 import { InputFieldFactory } from './inputFields/InputFieldFactory';
 import { InputFieldArgumentType, InputFieldDeclaration, InputFieldDeclarationParser } from './parsers/InputFieldDeclarationParser';
-import { isTruthy, MetaBindBindTargetError, MetaBindInternalError } from './utils/Utils';
+import { isFalsy, isTruthy, MetaBindBindTargetError, MetaBindInternalError } from './utils/Utils';
 import { AbstractInputFieldArgument } from './inputFieldArguments/AbstractInputFieldArgument';
 import { ClassInputFieldArgument } from './inputFieldArguments/ClassInputFieldArgument';
 import { getFrontmatterOfTFile, updateOrInsertFieldInTFile } from '@opd-libs/opd-metadata-lib/lib/API';
@@ -47,12 +47,10 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 		this.intervalCounter = 0;
 		this.inputFieldDeclaration = declaration;
 
-		if (isTruthy(error)) {
-			console.warn(error);
-		} else {
-			this.uid = this.plugin.markDownInputFieldIndex;
-			this.plugin.markDownInputFieldIndex += 1;
+		this.uid = this.plugin.markDownInputFieldIndex;
+		this.plugin.markDownInputFieldIndex += 1;
 
+		if (!error) {
 			try {
 				if (this.inputFieldDeclaration.isBound) {
 					this.parseBindTarget();
@@ -78,9 +76,9 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 			throw new MetaBindInternalError('inputFieldDeclaration is undefined, can not parse bind target');
 		}
 
-		const bindTargetParts = this.inputFieldDeclaration.bindTarget.split('#');
-		let bindTargetFileName;
-		let bindTargetMetadataFieldName;
+		const bindTargetParts: string[] = this.inputFieldDeclaration.bindTarget.split('#');
+		let bindTargetFileName: string;
+		let bindTargetMetadataFieldName: string;
 
 		if (bindTargetParts.length === 1) {
 			// the bind target is in the same file

src/inputFieldArguments/InputFieldArgumentFactory.ts

@@ -7,9 +7,10 @@ import { MaxValueInputFieldArgument } from './MaxValueInputFieldArgument';
 import { OptionInputFieldArgument } from './OptionInputFieldArgument';
 import { TitleInputFieldArgument } from './TitleInputFieldArgument';
 import { AlignRightInputFieldArgument } from './AlignRightInputFieldArgument';
+import { AbstractInputFieldArgument } from './AbstractInputFieldArgument';
 
 export class InputFieldArgumentFactory {
-	static createInputFieldArgument(argumentIdentifier: string) {
+	static createInputFieldArgument(argumentIdentifier: string): AbstractInputFieldArgument {
 		if (argumentIdentifier === InputFieldArgumentType.CLASS) {
 			return new ClassInputFieldArgument();
 		} else if (argumentIdentifier === InputFieldArgumentType.ADD_LABELS) {

src/main.ts

@@ -1,7 +1,7 @@
-import { CachedMetadata, MarkdownPostProcessorContext, Plugin, TFile } from 'obsidian';
+import { CachedMetadata, editorEditorField, MarkdownPostProcessorContext, Plugin, TFile } from 'obsidian';
 import { DEFAULT_SETTINGS, MetaBindPluginSettings, MetaBindSettingTab } from './settings/Settings';
 import { InputFieldMarkdownRenderChild, InputFieldMarkdownRenderChildType } from './InputFieldMarkdownRenderChild';
-import { getFileName, isPath, isTruthy, removeFileEnding } from './utils/Utils';
+import { getFileName, isPath, isTruthy, MetaBindBindTargetError, removeFileEnding } from './utils/Utils';
 import { Logger } from './utils/Logger';
 import { DateParser } from './parsers/DateParser';
 import { InputFieldArgumentType, InputFieldDeclaration, InputFieldDeclarationParser, InputFieldType } from './parsers/InputFieldDeclarationParser';
@@ -57,12 +57,12 @@ export default class MetaBindPlugin extends Plugin {
 	}
 
 	/**
-	 * Accessable function for building an input field.
+	 * Accessible function for building an input field.
 	 *
-	 * @param {string|InputFieldDeclaration} declaration The field declaration string or data.
-	 * @param {string} sourcePath The path of the file the element is being inserted into
-	 * @param {HTMLElement} container The element to fill with the input element
-	 * @param {InputFieldMarkdownRenderChildType} renderType Inline or Code Block
+	 * @param {string|InputFieldDeclaration} declaration The input field declaration as a string or object.
+	 * @param {string} sourcePath The path of the file the element will be inserted into.
+	 * @param {HTMLElement} container The container element for the input element.
+	 * @param {InputFieldMarkdownRenderChildType} renderType Inline or Code Block.
 	 *
 	 * @returns The render child produced.
 	 */
@@ -72,16 +72,19 @@ export default class MetaBindPlugin extends Plugin {
 		container: HTMLElement,
 		renderType: InputFieldMarkdownRenderChildType = InputFieldMarkdownRenderChildType.INLINE_CODE_BLOCK
 	): InputFieldMarkdownRenderChild {
-		let error = undefined;
+		let error: string | undefined;
 
 		try {
 			if (typeof declaration === 'string') {
 				declaration = InputFieldDeclarationParser.parseString(declaration);
 			} else {
 				declaration = InputFieldDeclarationParser.parseDeclaration(declaration);
 			}
-		} catch (error) {
-			console.warn(error);
+		} catch (e: any) {
+			if (e instanceof Error) {
+				error = e.message;
+				console.warn(e);
+			}
 		}
 
 		return new InputFieldMarkdownRenderChild(container, renderType, declaration as InputFieldDeclaration, this, sourcePath, error);
@@ -91,7 +94,7 @@ export default class MetaBindPlugin extends Plugin {
 	 * Helper method to build a declaration from some initial data or a string.
 	 *
 	 * @param {string | InputFieldDeclaration | {}} declarationData The base declaration data or a string to parse for it. Can also be an empty object with the other arguments provided to fill it.
-	 * @param {Record<InputFieldArgumentType, string> | {} | undefined} inputFieldArguments (Optional) The arguments, indexed by name.
+	 * @param {Record<InputFieldArgumentType, string> | {} | undefined} inputFieldArguments (Optional) The input field arguments, indexed by argument name.
 	 * @param {InputFieldType | undefined} inputFieldType (Optional) The input field type if not provided in the base object.
 	 * @param {boolean | undefined} isBound (Optional) If the field should try to be bound to a bindTarget.
 	 * @param {string | undefined} bindTarget (Optional) The bind target of the field.
@@ -110,12 +113,18 @@ export default class MetaBindPlugin extends Plugin {
 		if (typeof declarationData === 'string') {
 			return InputFieldDeclarationParser.parseString(declarationData);
 		} else {
-			const fullBase = declarationData as InputFieldDeclaration;
-			fullBase.inputFieldType = inputFieldType ?? fullBase.inputFieldType ?? InputFieldType.INVALID;
-			fullBase.isBound = isBound ?? fullBase.isBound ?? false ?? isTruthy(bindTarget);
-			fullBase.bindTarget = bindTarget ?? fullBase.bindTarget ?? undefined;
+			const declarationBase = declarationData as InputFieldDeclaration;
+			declarationBase.inputFieldType = inputFieldType ?? declarationBase.inputFieldType ?? InputFieldType.INVALID;
+			declarationBase.isBound = isBound ?? declarationBase.isBound ?? false;
+			declarationBase.bindTarget = bindTarget ?? declarationBase.bindTarget ?? undefined;
+
+			// if the input field is bound should be determined by `isBound`
+			// `isBound` is true, `bindTarget` must be set
+			if (declarationBase.isBound && !declarationBase.bindTarget) {
+				throw new MetaBindBindTargetError('input field declaration is bound but bind target is undefined');
+			}
 
-			return InputFieldDeclarationParser.parseDeclaration(fullBase, inputFieldArguments, templateName);
+			return InputFieldDeclarationParser.parseDeclaration(declarationBase, inputFieldArguments, templateName);
 		}
 	}
 

src/parsers/InputFieldDeclarationParser.ts

@@ -15,6 +15,7 @@ export enum InputFieldType {
 	TIME = 'time',
 	DATE_PICKER = 'date_picker',
 	NUMBER = 'number',
+
 	INVALID = 'invalid',
 }
 
@@ -31,11 +32,39 @@ export enum InputFieldArgumentType {
 }
 
 export interface InputFieldDeclaration {
+	/**
+	 * The full declaration of the input field including the "INPUT[]".
+	 * e.g.
+	 * INPUT[input_type(argument_name(value)):bind_target]
+	 */
 	fullDeclaration: string;
+	/**
+	 * Trimmed declaration of the input field including without the "INPUT[]".
+	 * e.g.
+	 * input_type(argument_name(value)):bind_target
+	 */
 	declaration: string;
+	/**
+	 * The type of the input field.
+	 * e.g.
+	 * input_type
+	 */
 	inputFieldType: InputFieldType;
+	/**
+	 * Whether the input field is bound.
+	 * e.g.
+	 * true
+	 */
 	isBound: boolean;
+	/**
+	 * The frontmatter field the input field is bound to.
+	 * e.g.
+	 * bind_target
+	 */
 	bindTarget: string;
+	/**
+	 * A collection of the input field arguments.
+	 */
 	argumentContainer: InputFieldArgumentContainer;
 }
 
@@ -65,7 +94,7 @@ export class InputFieldDeclarationParser {
 		fullDeclaration.inputFieldType = InputFieldDeclarationParser.getInputFieldType(fullDeclaration.inputFieldType);
 
 		// template check:
-		let useTemplate = isTruthy(templateName) && typeof templateName === 'string';
+		let useTemplate: boolean = isTruthy(templateName) && typeof templateName === 'string';
 		if (useTemplate) {
 			InputFieldDeclarationParser.applyTemplate(fullDeclaration, templateName);
 		}
@@ -237,15 +266,20 @@ export class InputFieldDeclarationParser {
 		return InputFieldType.INVALID;
 	}
 
-	static applyTemplate(fullDeclaration: InputFieldDeclaration, templateName: string | null | undefined) {
+	static applyTemplate(inputFieldDeclaration: InputFieldDeclaration, templateName: string | null | undefined) {
+		if (!templateName) {
+			return;
+		}
+
 		const template = InputFieldDeclarationParser.templates.filter(x => x.identifier === templateName).first()?.template;
-		if (template) {
-			fullDeclaration.bindTarget = fullDeclaration.bindTarget || template.bindTarget;
-			fullDeclaration.isBound = fullDeclaration.isBound || template.isBound;
-			fullDeclaration.inputFieldType = fullDeclaration.inputFieldType === InputFieldType.INVALID ? template.inputFieldType : fullDeclaration.inputFieldType || template.inputFieldType;
-			fullDeclaration.argumentContainer = template.argumentContainer.mergeByOverride(fullDeclaration.argumentContainer);
-		} else {
+		if (!template) {
 			throw new MetaBindParsingError(`unknown template name \'${templateName}\'`);
 		}
+
+		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);
 	}
 }