more api work

Author: mProjectsCode

exampleVault/Dataview.md

@@ -0,0 +1,5 @@
+
+```dataviewjs
+console.log(test);
+asdasd asdasd
+```

exampleVault/Test.md

@@ -1,14 +1,17 @@
-asd
+---
+text: taasdasd
+number: 12234234
+---
+
+Some text
 ```js-engine
 let a = "test";
 return a;
 ```
-asdasd
-asdasd
-asdasd
+Some more text
 
 ```js-engine
-let markdownBuilder = engine.createMarkdownBuilder()
+let markdownBuilder = engine.markdown.createBuilder()
 
 markdownBuilder.createHeading(2, "Test Heading")
 markdownBuilder.createParagraph("This is a test paragraph.")
@@ -44,8 +47,23 @@ let lib = await engine.importJs("lib.js");
 return lib.getGreeting();
 ```
 
-# Async Tewst
+# Async Test
 
 ```js-engine
 return await engine.test()
+```
+
+# Meta Bind Test
+
+```js-engine
+const meta_bind_api = engine.getPlugin("obsidian-meta-bind-plugin").api
+
+const div1 = container.createDiv()
+const div2 = container.createDiv()
+
+const inputField = meta_bind_api.createInputFieldFromString("INPUT[text:text]", "INLINE", context.file.path, div1);
+const inputField2 = meta_bind_api.createInputFieldFromString("INPUT[number:number]", "INLINE", context.file.path, div2);
+
+component.addChild(inputField)
+component.addChild(inputField2)
 ```

src/ArgumentManager.ts

@@ -1,4 +1,4 @@
-import { App, TFile } from 'obsidian';
+import {App, Component, TFile} from 'obsidian';
 import JsEnginePlugin from './main';
 
 export interface ExecutionContext {
@@ -31,13 +31,21 @@ export class ArgumentManager {
 		});
 	}
 
-	constructArgs(context: ExecutionContext): ExecutionArgument[] {
+	constructArgs(context: ExecutionContext, component: Component, container: HTMLElement): ExecutionArgument[] {
 		return [
 			...this.defaultArgs,
 			{
 				key: 'context',
 				value: context,
 			},
+			{
+				key: 'component',
+				value: component,
+			},
+			{
+				key: 'container',
+				value: container,
+			},
 		];
 	}
 }

src/JsEngine.ts

@@ -14,13 +14,12 @@ export class JsEngine {
 		this.argsManager = new ArgumentManager(app, plugin);
 	}
 
-	async execute(code: string, context: ExecutionContext): Promise<unknown> {
+	async execute(code: string, args: ExecutionArgument[]): Promise<unknown> {
 		if (!code) {
 			return;
 		}
 
 		const AsyncFunction = async function (): Promise<void> {}.constructor;
-		const args: ExecutionArgument[] = this.argsManager.constructArgs(context);
 
 		// @ts-ignore
 		const func: any = new AsyncFunction(...args.map(x => x.key), code);

src/JsMDRC.ts

@@ -1,9 +1,9 @@
-import { MarkdownRenderChild, MarkdownRenderer, TAbstractFile, TFile } from 'obsidian';
+import { MarkdownRenderChild, TAbstractFile, TFile } from 'obsidian';
 import JsEnginePlugin from './main';
 import { MarkdownPostProcessorContext } from 'obsidian/publish';
-import { ExecutionContext } from './ArgumentManager';
-import { MarkdownBuilder } from './markdownBuilder/MarkdownBuilder';
-import { MarkdownString } from './api/MarkdownAPI';
+import {ExecutionArgument, ExecutionContext} from './ArgumentManager';
+import { MarkdownBuilder } from './api/markdown/MarkdownBuilder';
+import {MarkdownString} from './api/markdown/MarkdownString';
 
 export class JsMDRC extends MarkdownRenderChild {
 	plugin: JsEnginePlugin;
@@ -40,16 +40,24 @@ export class JsMDRC extends MarkdownRenderChild {
 		};
 	}
 
-	async tryRun(): Promise<unknown> {
+	buildExecutionArgs(container: HTMLElement): ExecutionArgument[] {
 		if (!this.plugin.jsEngine) {
-			return;
+			throw new Error("jsEngine is undefined");
+		}
+		return this.plugin.jsEngine?.argsManager.constructArgs(this.buildExecutionContext(), this, container);
+	}
+
+	async tryRun(args: ExecutionArgument[]): Promise<unknown> {
+		if (!this.plugin.jsEngine) {
+			throw new Error("jsEngine is undefined");
 		}
 
-		return this.plugin.jsEngine.execute(this.content, this.buildExecutionContext());
+		return this.plugin.jsEngine.execute(this.content, args);
 	}
 
 	async tryRender(container: HTMLElement): Promise<void> {
-		let res = await this.tryRun();
+		const args = this.buildExecutionArgs(container);
+		let res = await this.tryRun(args);
 
 		if (!res) {
 			return;
@@ -83,7 +91,6 @@ export class JsMDRC extends MarkdownRenderChild {
 			await this.tryRender(this.containerEl);
 		} catch (e) {
 			this.containerEl.innerText = e instanceof Error ? e.stack?.toString() ?? '' : (e as string);
-			console.log(e);
 		}
 	}
 

src/api/API.ts

@@ -1,23 +1,18 @@
-import { MarkdownBuilder } from '../markdownBuilder/MarkdownBuilder';
-import { MarkdownString } from './MarkdownAPI';
-import { App } from 'obsidian';
+import {MarkdownAPI} from './MarkdownAPI';
+import {App, Plugin} from 'obsidian';
 import JsEnginePlugin from '../main';
 
 export class API {
-	app: App;
-	plugin: JsEnginePlugin;
+	readonly app: App;
+	readonly plugin: JsEnginePlugin;
+	readonly markdown: MarkdownAPI;
+
 
 	constructor(app: App, plugin: JsEnginePlugin) {
 		this.app = app;
 		this.plugin = plugin;
-	}
-
-	createMarkdownBuilder(): MarkdownBuilder {
-		return new MarkdownBuilder();
-	}
 
-	createMarkdown(markdown: string): MarkdownString {
-		return new MarkdownString(markdown);
+		this.markdown = new MarkdownAPI(app, plugin);
 	}
 
 	/**
@@ -29,4 +24,8 @@ export class API {
 		const fullPath = this.app.vault.adapter.getResourcePath(path);
 		return import(fullPath);
 	}
+
+	getPlugin(pluginId: string): Plugin {
+		return this.app.plugins.getPlugin(pluginId);
+	}
 }

src/api/MarkdownAPI.ts

@@ -1,15 +1,79 @@
-import { Component, MarkdownRenderer } from 'obsidian';
+import {App} from 'obsidian';
+import {MarkdownBuilder} from './markdown/MarkdownBuilder';
+import JsEnginePlugin from '../main';
+import {MarkdownString} from './markdown/MarkdownString';
+import {
+	BlockQuoteElement,
+	CalloutElement,
+	CodeBlockElement,
+	CodeElement,
+	HeadingElement,
+	ParagraphElement,
+	TableElement,
+	TextElement,
+} from './markdown/AbstractMarkdownElementContainer';
 
-export class MarkdownString {
-	content: string;
 
-	constructor(content: string) {
-		this.content = content;
+
+export class MarkdownAPI {
+	readonly app: App;
+	readonly plugin: JsEnginePlugin;
+
+
+	constructor(app: App, plugin: JsEnginePlugin) {
+		this.app = app;
+		this.plugin = plugin;
 	}
 
-	async render(element: HTMLElement, sourcePath: string, component: Component): Promise<void> {
-		await MarkdownRenderer.renderMarkdown(this.content, element, sourcePath, component);
+	createBuilder(): MarkdownBuilder {
+		return new MarkdownBuilder();
+	}
+
+	create(markdown: string): MarkdownString {
+		return new MarkdownString(markdown);
+	}
+
+	createText(text: string): TextElement {
+		return new TextElement(text, false, false, false);
+	}
+
+	createBoldText(text: string): TextElement {
+		return new TextElement(text, true, false, false);
+	}
+
+	createCursiveText(text: string): TextElement {
+		return new TextElement(text, false, true, false);
+	}
+
+	createUnderlinedText(text: string): TextElement {
+		return new TextElement(text, false, false, true);
 	}
-}
 
-export class MarkdownAPI {}
+	createCode(text: string): CodeElement {
+		return new CodeElement(text);
+	}
+
+	createParagraph(content: string): ParagraphElement {
+		return new ParagraphElement(content);
+	}
+
+	createHeading(level: number, content: string): HeadingElement {
+		return new HeadingElement(level, content);
+	}
+
+	createBlockQuote(): BlockQuoteElement {
+		return new BlockQuoteElement();
+	}
+
+	createCallout(title: string, type: string, args: string = ''): CalloutElement {
+		return new CalloutElement(title, type, args);
+	}
+
+	createCodeBlock(language: string, content: string): CodeBlockElement {
+		return new CodeBlockElement(language, content);
+	}
+
+	createTable(header: string[], body: string[][]): TableElement {
+		return new TableElement(header, body);
+	}
+}

src/markdownBuilder/AbstractMarkdownElement.ts renamed to src/api/markdown/AbstractMarkdownElement.ts

@@ -1,5 +1,5 @@
 import { MarkdownElementType } from './MarkdownElementType';
-import { MarkdownString } from '../api/MarkdownAPI';
+import { MarkdownString } from '../MarkdownAPI';
 
 export abstract class AbstractMarkdownElement {
 	abstract toString(): string;