untested new api

Author: mProjectsCode

exampleVault/examples.md

@@ -1,13 +1,12 @@
 ---
-slider1: 7
+slider1: 8
 suggest: test
 toggle1: false
 Domestic_tasks:
   - Lunch 🍲
 Meditate: 100
 Slept: 00:00
 select: option c
-nested: 
 ---
 
 ## In callouts
@@ -62,22 +61,23 @@ option(option d)
 Lorem ipsum dolor sit amet, `INPUT[date():other note#date]` consectetur adipiscing elit. Pellentesque sit amet porttitor arcu. Quisque scelerisque dolor augue, et posuere nulla bibendum nec. `INPUT[date():other note#date]` Curabitur sed rhoncus nisl. Maecenas nisi justo, viverra vel tempus vel, hendrerit at metus. `INPUT[date_picker():other note#date]`  asdasd asdasdasd
 
 ## Templates
-- unknown tempalate
-	- `INPUT[][toggle:toggle1]`
-	- `INPUT[nonExistantTemplate][toggle:toggle1]`
-- `INPUT[toggleTemplate][]`
+- `INPUT[][toggle:toggle1]` empty template
+- `INPUT[nonExistantTemplate][toggle:toggle1]` unknown template
+- `INPUT[toggleTemplate][]` 
 
 ## Error Messages
 - `INPUT[text():meta bind/nonExistantFile#title]`
 - `INPUT[slider(nonExistantArgument)]`
 - `INPUT[slider]`
 
-- `INPUT[inlineSelect(option(option a),option(option b),option(option c),option(option d)):select]`
+- `INPUT[inlineSelect(option(option a),option(option b),option(option c),option(option d):select]`
 
 
 Lorem ipsum dolor sit amet, `INPUT[text():meta bind/nonExistantFile#title]` consectetur adipiscing elit. Pellentesque sit amet porttitor arcu. Quisque scelerisque dolor augue, et posuere nulla bibendum nec. `INPUT[slider(nonExistantArgument)]` Curabitur sed rhoncus nisl. Maecenas nisi justo, viverra vel tempus vel, hendrerit at metus. `INPUT[select(option(option a),option(option b),option(option c),option(option d)):select]` asdasd asdasdasd
 
 Code block error
 ```meta-bind
 INPUT[slider(nonExistantArgument)]
-```
+```
+
+`INPUT[inlineSelect(option(a), option(b), option(c)]`

exampleVault/other note.md

@@ -2,7 +2,7 @@
 tags: test
 title: test test
 select: option b
-date: Thursday, July 20th 2023
+date: Wednesday, August 16th 2023
 time: 19:20
 multi-select:
   - option a

src/api/API.ts

@@ -1,102 +1,86 @@
-import { InlineAPI } from './InlineAPI';
 import { InputFieldMDRC, RenderChildType } from '../renderChildren/InputFieldMDRC';
-import { InputFieldArgumentType, InputFieldDeclaration, InputFieldDeclarationParser, InputFieldType } from '../parsers/InputFieldDeclarationParser';
-import { ErrorLevel, MetaBindBindTargetError, MetaBindParsingError } from '../utils/errors/MetaBindErrors';
-import { isTruthy } from '../utils/Utils';
+import { InputFieldDeclaration } from '../parsers/InputFieldDeclarationParser';
 import { JsViewFieldDeclaration, ViewFieldDeclaration, ViewFieldDeclarationParser } from '../parsers/ViewFieldDeclarationParser';
 import { BindTargetParser } from '../parsers/BindTargetParser';
 import { ViewFieldMDRC } from '../renderChildren/ViewFieldMDRC';
 import { JsViewFieldMDRC } from '../renderChildren/JsViewFieldMDRC';
-import { ErrorCollection } from '../utils/errors/ErrorCollection';
 import MetaBindPlugin from '../main';
-import { DeclarationParser, NewInputFieldDeclarationParser } from '../parsers/newInputFieldParser/InputFieldParser';
+import { NewInputFieldDeclarationParser, UnvalidatedInputFieldDeclaration } from '../parsers/newInputFieldParser/InputFieldParser';
+import { Component, MarkdownPostProcessorContext } from 'obsidian';
 
 export class API {
 	public plugin: MetaBindPlugin;
-	public inputFieldParser: InputFieldDeclarationParser;
+	// public inputFieldParser: InputFieldDeclarationParser;
 	public newInputFieldParser: NewInputFieldDeclarationParser;
 	public viewFieldParser: ViewFieldDeclarationParser;
 	public bindTargetParser: BindTargetParser;
 
 	constructor(plugin: MetaBindPlugin) {
 		this.plugin = plugin;
 
-		this.inputFieldParser = new InputFieldDeclarationParser();
+		// this.inputFieldParser = new InputFieldDeclarationParser();
 		this.newInputFieldParser = new NewInputFieldDeclarationParser(this.plugin);
 		this.viewFieldParser = new ViewFieldDeclarationParser();
 		this.bindTargetParser = new BindTargetParser(this.plugin);
 	}
 
-	public createInlineAPI(filePath: string, container?: HTMLElement): InlineAPI {
-		return new InlineAPI(this, filePath, container);
-	}
-
 	public createInputField(
-		declaration: InputFieldDeclaration,
-		templateName: string | undefined,
-		renderChildType: RenderChildType,
+		unvalidatedDeclaration: UnvalidatedInputFieldDeclaration,
+		renderType: RenderChildType,
 		filePath: string,
-		container: HTMLElement
+		containerEl: HTMLElement,
+		component: Component | MarkdownPostProcessorContext
 	): InputFieldMDRC {
-		if (!Object.values(RenderChildType).contains(renderChildType)) {
-			throw new MetaBindParsingError(ErrorLevel.CRITICAL, 'failed to create input field', `unknown render child type '${renderChildType}'`);
-		}
-		declaration = this.inputFieldParser.parseDeclaration(declaration, undefined, templateName);
-		return new InputFieldMDRC(container, renderChildType, declaration, this.plugin, filePath, self.crypto.randomUUID());
-	}
-
-	public createInputFieldFromString(fullDeclaration: string, renderType: RenderChildType, filePath: string, container: HTMLElement): InputFieldMDRC {
-		const declaration: InputFieldDeclaration = this.newInputFieldParser.parseString(fullDeclaration, filePath);
-		return new InputFieldMDRC(container, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
-	}
+		const declaration = this.newInputFieldParser.validateDeclaration(unvalidatedDeclaration);
 
-	public createViewFieldFromString(fullDeclaration: string, renderType: RenderChildType, filePath: string, container: HTMLElement): ViewFieldMDRC {
-		const declaration: ViewFieldDeclaration = this.viewFieldParser.parseString(fullDeclaration);
-		return new ViewFieldMDRC(container, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
-	}
+		const inputField = new InputFieldMDRC(containerEl, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
+		component.addChild(inputField);
 
-	public createJsViewFieldFromString(fullDeclaration: string, renderType: RenderChildType, filePath: string, container: HTMLElement): JsViewFieldMDRC {
-		const declaration: JsViewFieldDeclaration = this.viewFieldParser.parseJsString(fullDeclaration);
-		return new JsViewFieldMDRC(container, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
+		return inputField;
 	}
 
-	public createInputFieldDeclaration(
-		inputFieldType: InputFieldType,
-		inputFieldArguments?: { type: InputFieldArgumentType; value: string }[]
-	): InputFieldDeclaration {
-		if (this.inputFieldParser.getInputFieldType(inputFieldType) === InputFieldType.INVALID) {
-			throw new MetaBindParsingError(ErrorLevel.CRITICAL, 'failed to create input field declaration', `input field type '${inputFieldType}' is invalid`);
-		}
+	public createInputFieldFromString(
+		fullDeclaration: string,
+		renderType: RenderChildType,
+		filePath: string,
+		containerEl: HTMLElement,
+		component: Component | MarkdownPostProcessorContext
+	): InputFieldMDRC {
+		const declaration: InputFieldDeclaration = this.newInputFieldParser.parseString(fullDeclaration);
 
-		const errorCollection = new ErrorCollection('InputFieldDeclaration');
+		const inputField = new InputFieldMDRC(containerEl, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
+		component.addChild(inputField);
 
-		return {
-			declaration: undefined,
-			fullDeclaration: undefined,
-			inputFieldType: inputFieldType,
-			argumentContainer: this.inputFieldParser.parseArguments(inputFieldType, inputFieldArguments, errorCollection),
-			isBound: false,
-			bindTarget: '',
-			errorCollection: errorCollection,
-		} as InputFieldDeclaration;
+		return inputField;
 	}
 
-	public createInputFieldDeclarationFromString(fullDeclaration: string): InputFieldDeclaration {
-		return this.inputFieldParser.parseString(fullDeclaration);
+	public createViewFieldFromString(
+		fullDeclaration: string,
+		renderType: RenderChildType,
+		filePath: string,
+		container: HTMLElement,
+		component: Component | MarkdownPostProcessorContext
+	): ViewFieldMDRC {
+		const declaration: ViewFieldDeclaration = this.viewFieldParser.parseString(fullDeclaration);
+
+		const viewField = new ViewFieldMDRC(container, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
+		component.addChild(viewField);
+
+		return viewField;
 	}
 
-	public bindInputFieldDeclaration(declaration: InputFieldDeclaration, bindTargetField: string, bindTargetFile?: string): InputFieldDeclaration {
-		if (bindTargetFile && !bindTargetField) {
-			throw new MetaBindBindTargetError(
-				ErrorLevel.ERROR,
-				'failed to bind input field declaration',
-				'if a bind target file is specified, a bind target field must also be specified'
-			);
-		}
+	public createJsViewFieldFromString(
+		fullDeclaration: string,
+		renderType: RenderChildType,
+		filePath: string,
+		containerEl: HTMLElement,
+		component: Component | MarkdownPostProcessorContext
+	): JsViewFieldMDRC {
+		const declaration: JsViewFieldDeclaration = this.viewFieldParser.parseJsString(fullDeclaration);
 
-		declaration.isBound = isTruthy(bindTargetField);
-		declaration.bindTarget = bindTargetFile ? bindTargetFile + '#' + bindTargetField : bindTargetField;
+		const viewField = new JsViewFieldMDRC(containerEl, renderType, declaration, this.plugin, filePath, self.crypto.randomUUID());
+		component.addChild(viewField);
 
-		return declaration;
+		return viewField;
 	}
 }

src/api/InlineAPI.ts

@@ -0,0 +1,92 @@
+import { InputFieldArgumentType, InputFieldType } from '../parsers/InputFieldDeclarationParser';
+import { UnvalidatedInputFieldDeclaration } from '../parsers/newInputFieldParser/InputFieldParser';
+import { ErrorCollection } from '../utils/errors/ErrorCollection';
+import { API } from './API';
+import { useSyncExternalStore } from 'preact/compat';
+
+export class InputFieldAPI {
+	private readonly api: API;
+
+	constructor(api: API) {
+		this.api = api;
+	}
+
+	public createInputFieldDeclaration(
+		inputFieldType?: InputFieldType,
+		inputFieldArguments?: { name: InputFieldArgumentType; value?: string }[]
+	): UnvalidatedInputFieldDeclaration {
+		const errorCollection = new ErrorCollection('input field declaration');
+
+		const mappedArguments = (inputFieldArguments ?? []).map(x => ({
+			name: { result: x.name },
+			value: x.value !== undefined ? { result: x.value } : undefined,
+		}));
+
+		return {
+			fullDeclaration: '',
+			inputFieldType: inputFieldType ? { result: inputFieldType } : undefined,
+			bindTargetFile: undefined,
+			bindTargetPath: undefined,
+			arguments: mappedArguments,
+			errorCollection: errorCollection,
+		} as UnvalidatedInputFieldDeclaration;
+	}
+
+	public createInputFieldDeclarationFromString(fullDeclaration: string): UnvalidatedInputFieldDeclaration {
+		return this.api.newInputFieldParser.parseStringWithoutValidation(fullDeclaration);
+	}
+
+	public setType(unvalidatedDeclaration: UnvalidatedInputFieldDeclaration, inputFieldType: InputFieldType): UnvalidatedInputFieldDeclaration {
+		unvalidatedDeclaration.inputFieldType = { result: inputFieldType };
+
+		return unvalidatedDeclaration;
+	}
+
+	public setArguments(
+		unvalidatedDeclaration: UnvalidatedInputFieldDeclaration,
+		inputFieldArguments: { name: InputFieldArgumentType; value?: string | undefined }[]
+	): UnvalidatedInputFieldDeclaration {
+		unvalidatedDeclaration.arguments = inputFieldArguments.map(x => ({
+			name: { result: x.name },
+			value: x.value !== undefined ? { result: x.value } : undefined,
+		}));
+
+		return unvalidatedDeclaration;
+	}
+
+	public addArgument(
+		unvalidatedDeclaration: UnvalidatedInputFieldDeclaration,
+		inputFieldArguments: { name: InputFieldArgumentType; value?: string | undefined }[] | { name: InputFieldArgumentType; value?: string | undefined }
+	): UnvalidatedInputFieldDeclaration {
+		if (Array.isArray(inputFieldArguments)) {
+			unvalidatedDeclaration.arguments = unvalidatedDeclaration.arguments.concat(
+				inputFieldArguments.map(x => ({
+					name: { result: x.name },
+					value: x.value !== undefined ? { result: x.value } : undefined,
+				}))
+			);
+		} else {
+			unvalidatedDeclaration.arguments.push({
+				name: { result: inputFieldArguments.name },
+				value: inputFieldArguments.value !== undefined ? { result: inputFieldArguments.value } : undefined,
+			});
+		}
+
+		return unvalidatedDeclaration;
+	}
+
+	public setBindTargetFile(unvalidatedDeclaration: UnvalidatedInputFieldDeclaration, bindTargetFile: string): UnvalidatedInputFieldDeclaration {
+		unvalidatedDeclaration.bindTargetFile = { result: bindTargetFile };
+
+		return unvalidatedDeclaration;
+	}
+
+	public setBindTargetMetadataField(
+		unvalidatedDeclaration: UnvalidatedInputFieldDeclaration,
+		bindTargetMetadataField: string
+	): UnvalidatedInputFieldDeclaration {
+		unvalidatedDeclaration.bindTargetPath = { result: bindTargetMetadataField };
+
+		return unvalidatedDeclaration;
+	}
+}

src/api/InputFieldAPI.ts

@@ -24,16 +24,13 @@ export abstract class MarkdownRenderChildWidget<T extends AbstractMDRC> extends
 		return other.content === this.content;
 	}
 
-	abstract createRenderChild(container: HTMLElement): T;
+	abstract createRenderChild(container: HTMLElement, component: Component): T;
 
 	public toDOM(view: EditorView): HTMLElement {
 		const div = document.createElement('span');
 		div.addClass('cm-inline-code');
 
-		this.renderChild = this.createRenderChild(div);
-		this.renderChild.load();
-
-		this.parentComponent.addChild(this.renderChild);
+		this.renderChild = this.createRenderChild(div, this.parentComponent);
 
 		return div;
 	}
@@ -45,14 +42,14 @@ export abstract class MarkdownRenderChildWidget<T extends AbstractMDRC> extends
 }
 
 export class ViewFieldWidget extends MarkdownRenderChildWidget<ViewFieldMDRC> {
-	public createRenderChild(container: HTMLElement): ViewFieldMDRC {
-		return this.plugin.api.createViewFieldFromString(this.content, RenderChildType.INLINE, this.filePath, container);
+	public createRenderChild(container: HTMLElement, component: Component): ViewFieldMDRC {
+		return this.plugin.api.createViewFieldFromString(this.content, RenderChildType.INLINE, this.filePath, container, component);
 	}
 }
 
 export class InputFieldWidget extends MarkdownRenderChildWidget<InputFieldMDRC> {
-	public createRenderChild(container: HTMLElement): InputFieldMDRC {
-		return this.plugin.api.createInputFieldFromString(this.content, RenderChildType.INLINE, this.filePath, container);
+	public createRenderChild(container: HTMLElement, component: Component): InputFieldMDRC {
+		return this.plugin.api.createInputFieldFromString(this.content, RenderChildType.INLINE, this.filePath, container, component);
 	}
 }