api part 2

Author: mProjectsCode

exampleVault/Meta Bind JS.md

@@ -0,0 +1,20 @@
+---
+select: a
+---
+
+test
+```meta-bind-js
+const declaration = mb.createDeclaration(
+	'select',
+	[
+		{type: 'option', value: 'a'},
+		{type: 'option', value: 'c'},
+	],
+	'select'
+);
+
+const inputField = mb.createInputField(declaration, undefined, 'block');
+
+ctx.addChild(inputField);
+```
+test

src/API.ts

@@ -1,7 +1,7 @@
-import { App, TFile } from 'obsidian';
+import { App } from 'obsidian';
 import MetaBindPlugin from './main';
 import { InlineAPI } from './InlineAPI';
-import { InputFieldMarkdownRenderChild, InputFieldMarkdownRenderChildType } from './InputFieldMarkdownRenderChild';
+import { InputFieldMarkdownRenderChild, RenderChildType } from './InputFieldMarkdownRenderChild';
 import { InputFieldArgumentType, InputFieldDeclaration, InputFieldDeclarationParser, InputFieldType } from './parsers/InputFieldDeclarationParser';
 import { MetaBindBindTargetError, MetaBindParsingError } from './utils/MetaBindErrors';
 import { isTruthy } from './utils/Utils';
@@ -18,51 +18,50 @@ export class API {
 		this.parser = new InputFieldDeclarationParser();
 	}
 
-	public createInlineAPI(file: TFile, container?: HTMLElement): InlineAPI {
-		return new InlineAPI(this, file, container);
+	public createInlineAPI(filePath: string, container?: HTMLElement): InlineAPI {
+		return new InlineAPI(this, filePath, container);
 	}
 
 	public createInputField(
 		declaration: InputFieldDeclaration,
 		templateName: string | undefined,
-		renderType: InputFieldMarkdownRenderChildType,
+		renderChildType: RenderChildType,
 		filePath: string,
 		container: HTMLElement
 	): InputFieldMarkdownRenderChild {
+		if (!Object.values(RenderChildType).contains(renderChildType)) {
+			throw new MetaBindParsingError(`unknown render child type '${renderChildType}'`);
+		}
 		declaration = this.parser.parseDeclaration(declaration, undefined, templateName);
-		return new InputFieldMarkdownRenderChild(container, renderType, declaration, this.plugin, filePath, crypto.randomUUID());
+		return new InputFieldMarkdownRenderChild(container, renderChildType, declaration, this.plugin, filePath, crypto.randomUUID());
 	}
 
-	public createInputFieldFromString(
-		fullDeclaration: string,
-		renderType: InputFieldMarkdownRenderChildType,
-		filePath: string,
-		container: HTMLElement
-	): InputFieldMarkdownRenderChild {
+	public createInputFieldFromString(fullDeclaration: string, renderType: RenderChildType, filePath: string, container: HTMLElement): InputFieldMarkdownRenderChild {
 		const declaration: InputFieldDeclaration = this.parser.parseString(fullDeclaration);
 		return new InputFieldMarkdownRenderChild(container, renderType, declaration, this.plugin, filePath, crypto.randomUUID());
 	}
 
 	public createDeclaration(
 		inputFieldType: InputFieldType,
-		inputFieldArguments?: Record<InputFieldArgumentType, string>,
-		bindTargetFile?: string,
-		bindTargetField?: string
+		inputFieldArguments?: { type: InputFieldArgumentType; value: string }[],
+		bindTargetField?: string,
+		bindTargetFile?: string
 	): InputFieldDeclaration {
 		if (bindTargetFile && !bindTargetField) {
 			throw new MetaBindBindTargetError('if a bind target file is specified, a bind target field must also be specified');
 		}
 
 		if (this.parser.getInputFieldType(inputFieldType) === InputFieldType.INVALID) {
-			throw new MetaBindParsingError(`input field type ${inputFieldType} is invalid`);
+			throw new MetaBindParsingError(`input field type '${inputFieldType}' is invalid`);
 		}
 
 		return {
 			declaration: undefined,
 			fullDeclaration: undefined,
 			inputFieldType: inputFieldType,
+			argumentContainer: this.parser.parseArguments(inputFieldType, inputFieldArguments),
 			isBound: isTruthy(bindTargetField),
-			bindTarget: bindTargetFile + '#' + bindTargetField,
+			bindTarget: bindTargetFile ? bindTargetFile + '#' + bindTargetField : bindTargetField,
 			error: undefined,
 		} as InputFieldDeclaration;
 	}

src/InlineAPI.ts

@@ -1,60 +1,54 @@
-import { TFile } from 'obsidian';
 import { API } from './API';
 import { InputFieldArgumentType, InputFieldDeclaration, InputFieldType } from './parsers/InputFieldDeclarationParser';
-import { InputFieldMarkdownRenderChild, InputFieldMarkdownRenderChildType } from './InputFieldMarkdownRenderChild';
+import { InputFieldMarkdownRenderChild, RenderChildType } from './InputFieldMarkdownRenderChild';
 
 export class InlineAPI {
 	public api: API;
-	public file: TFile;
+	public filePath: string;
 	public container?: HTMLElement;
 
-	constructor(api: API, file: TFile, container?: HTMLElement) {
+	constructor(api: API, filePath: string, container?: HTMLElement) {
 		this.api = api;
-		this.file = file;
+		this.filePath = filePath;
 		this.container = container;
 	}
 
-	public createInputField(declaration: InputFieldDeclaration, templateName: string | undefined, renderType: InputFieldMarkdownRenderChildType): InputFieldMarkdownRenderChild {
+	public createInputField(declaration: InputFieldDeclaration, templateName: string | undefined, renderType: RenderChildType): InputFieldMarkdownRenderChild {
 		if (!this.container) {
 			throw new Error('inline API was instanced without a container, please use "createInputFieldInContainer"');
 		}
 
-		return this.api.createInputField(declaration, templateName, renderType, this.file.path, this.container);
+		return this.api.createInputField(declaration, templateName, renderType, this.filePath, this.container);
 	}
 
 	public createInputFieldInContainer(
 		declaration: InputFieldDeclaration,
 		templateName: string | undefined,
-		renderType: InputFieldMarkdownRenderChildType,
+		renderChildType: RenderChildType,
 		container: HTMLElement
 	): InputFieldMarkdownRenderChild {
-		return this.api.createInputField(declaration, templateName, renderType, this.file.path, container);
+		return this.api.createInputField(declaration, templateName, renderChildType, this.filePath, container);
 	}
 
-	public createInputFieldFromString(fullDeclaration: string, renderType: InputFieldMarkdownRenderChildType, filePath: string): InputFieldMarkdownRenderChild {
+	public createInputFieldFromString(fullDeclaration: string, renderType: RenderChildType, filePath: string): InputFieldMarkdownRenderChild {
 		if (!this.container) {
 			throw new Error('inline API was instanced without a container, please use "createInputFieldFromStringInContainer"');
 		}
 
 		return this.api.createInputFieldFromString(fullDeclaration, renderType, filePath, this.container);
 	}
 
-	public createInputFieldFromStringInContainer(
-		fullDeclaration: string,
-		renderType: InputFieldMarkdownRenderChildType,
-		filePath: string,
-		container: HTMLElement
-	): InputFieldMarkdownRenderChild {
+	public createInputFieldFromStringInContainer(fullDeclaration: string, renderType: RenderChildType, filePath: string, container: HTMLElement): InputFieldMarkdownRenderChild {
 		return this.api.createInputFieldFromString(fullDeclaration, renderType, filePath, container);
 	}
 
 	public createDeclaration(
 		inputFieldType: InputFieldType,
-		inputFieldArguments?: Record<InputFieldArgumentType, string>,
-		bindTargetFile?: string,
-		bindTargetField?: string
+		inputFieldArguments?: { type: InputFieldArgumentType; value: string }[],
+		bindTargetField?: string,
+		bindTargetFile?: string
 	): InputFieldDeclaration {
-		return this.api.createDeclaration(inputFieldType, inputFieldArguments, bindTargetFile, bindTargetField);
+		return this.api.createDeclaration(inputFieldType, inputFieldArguments, bindTargetField, bindTargetFile);
 	}
 
 	public createDeclarationFromString(fullDeclaration: string): InputFieldDeclaration {

src/InputFieldMarkdownRenderChild.ts

@@ -12,9 +12,9 @@ import { ShowcaseInputFieldArgument } from './inputFieldArguments/ShowcaseInputF
 import { TitleInputFieldArgument } from './inputFieldArguments/TitleInputFieldArgument';
 import { isTruthy } from './utils/Utils';
 
-export enum InputFieldMarkdownRenderChildType {
-	INLINE_CODE_BLOCK,
-	CODE_BLOCK,
+export enum RenderChildType {
+	INLINE = 'inline',
+	BLOCK = 'block',
 }
 
 export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
@@ -24,7 +24,7 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 	uuid: string;
 	inputField: AbstractInputField | undefined;
 	error: string;
-	type: InputFieldMarkdownRenderChildType;
+	renderChildType: RenderChildType;
 
 	fullDeclaration?: string;
 	inputFieldDeclaration: InputFieldDeclaration;
@@ -35,7 +35,7 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 	metadataValueUpdateQueue: any[];
 	inputFieldValueUpdateQueue: any[];
 
-	constructor(containerEl: HTMLElement, type: InputFieldMarkdownRenderChildType, declaration: InputFieldDeclaration, plugin: MetaBindPlugin, filePath: string, uuid: string) {
+	constructor(containerEl: HTMLElement, type: RenderChildType, declaration: InputFieldDeclaration, plugin: MetaBindPlugin, filePath: string, uuid: string) {
 		super(containerEl);
 
 		if (!declaration.error) {
@@ -47,7 +47,7 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 		this.filePath = filePath;
 		this.uuid = uuid;
 		this.plugin = plugin;
-		this.type = type;
+		this.renderChildType = type;
 		this.fullDeclaration = declaration.fullDeclaration;
 
 		this.metadataValueUpdateQueue = [];
@@ -171,7 +171,7 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
 
 	addCardContainer(): boolean {
 		return (
-			this.type === InputFieldMarkdownRenderChildType.CODE_BLOCK &&
+			this.renderChildType === RenderChildType.BLOCK &&
 			(isTruthy(this.getArgument(InputFieldArgumentType.SHOWCASE)) ||
 				isTruthy(this.getArgument(InputFieldArgumentType.TITLE)) ||
 				this.inputFieldDeclaration.inputFieldType === InputFieldType.SELECT ||

src/ScriptMarkdownRenderChild.ts

@@ -0,0 +1,51 @@
+import { MarkdownPostProcessorContext, MarkdownRenderChild } from 'obsidian';
+import MetaBindPlugin from './main';
+import { getAPI } from 'obsidian-dataview';
+import { MetaBindJsError } from './utils/MetaBindErrors';
+
+export class ScriptMarkdownRenderChild extends MarkdownRenderChild {
+	content: string;
+	ctx: MarkdownPostProcessorContext;
+	plugin: MetaBindPlugin;
+
+	constructor(containerEl: HTMLElement, content: string, ctx: MarkdownPostProcessorContext, plugin: MetaBindPlugin) {
+		super(containerEl);
+		this.content = content;
+		this.ctx = ctx;
+		this.plugin = plugin;
+	}
+
+	async tryRun(): Promise<void> {
+		if (!this.content) {
+			throw new Error(`script content can not be empty for meta bind js code block`);
+		}
+
+		const isAsync = this.content.contains('await');
+		const funcConstructor = isAsync ? async function (): Promise<void> {}.constructor : Function;
+		const func: any = funcConstructor('app', 'mb', 'dv', 'filePath', 'ctx', this.content);
+		const inlineAPI = this.plugin.api.createInlineAPI(this.ctx.sourcePath, this.containerEl);
+
+		await Promise.resolve(func(this.plugin.app, inlineAPI, getAPI(this.plugin.app), this.ctx.sourcePath, this.ctx));
+	}
+
+	public async onload(): Promise<void> {
+		try {
+			await this.tryRun();
+		} catch (e) {
+			let m = '';
+			if (e instanceof Error) {
+				m = new MetaBindJsError(e.message).message;
+				console.log(e.stack);
+			} else {
+				m = new MetaBindJsError((e as any).toString()).message;
+			}
+
+			this.containerEl.addClass('meta-bind-plugin-card');
+
+			const preEl = this.containerEl.createEl('pre', { cls: 'language-js' });
+			const codeEl = preEl.createEl('code', { text: this.content, cls: 'language-js' });
+
+			const errorEl = this.containerEl.createEl('span', { text: m, cls: 'meta-bind-plugin-error' });
+		}
+	}
+}

src/inputFields/AbstractInputField.ts

@@ -1,8 +1,8 @@
 import { InputFieldMarkdownRenderChild } from '../InputFieldMarkdownRenderChild';
 
 export abstract class AbstractInputField {
-	static allowCodeBlock: boolean = true;
-	static allowInlineCodeBlock: boolean = true;
+	static allowBlock: boolean = true;
+	static allowInline: boolean = true;
 	inputFieldMarkdownRenderChild: InputFieldMarkdownRenderChild;
 	onValueChange: (value: any) => void | Promise<void>;
 

src/inputFields/ImageSuggest/ImageSuggestInputField.ts

@@ -9,7 +9,7 @@ import { OptionQueryInputFieldArgument } from '../../inputFieldArguments/OptionQ
 import { OptionInputFieldArgument } from '../../inputFieldArguments/OptionInputFieldArgument';
 
 export class ImageSuggestInputField extends AbstractInputField {
-	static allowInlineCodeBlock: boolean = false;
+	static allowInline: boolean = false;
 	container: HTMLDivElement | undefined;
 	component: ImageSuggestInput | undefined;
 	value: string;