reenable mathjs; remove dataview dep in build

Author: mProjectsCode

esbuild.config.mjs

@@ -18,7 +18,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 `;
 
-const context = await esbuild.context({
+const build = await esbuild.build({
 	banner: {
 		js: banner,
 	},
@@ -63,9 +63,6 @@ const context = await esbuild.context({
 	],
 });
 
-const build = await context.rebuild();
-console.log(await analyzeMetafile(build.metafile));
-
 const file = Bun.file('meta.txt');
 await Bun.write(file, JSON.stringify(build.metafile, null, '\t'));
 process.exit(0);

exampleVault/Examples.md

@@ -1,5 +1,5 @@
 ---
-slider1: 3
+slider1: 8
 suggest: test
 toggle1: false
 Domestic_tasks:

exampleVault/View Fields/View Field.md

@@ -1,5 +1,5 @@
 ---
-number1: 13
+number1: 12
 number2: 200
 unit: km
 distance: 12

src/fields/inputFields/fields/Suggester/SuggesterModalHelper.ts

@@ -1,5 +1,5 @@
 import { type MBLiteral } from '../../../../utils/Literal';
-import { type DataArray, type DataviewApi, getAPI, type Literal } from 'obsidian-dataview';
+import { type DataArray, type DataviewApi, type Literal } from 'obsidian-dataview';
 import { InputFieldArgumentType } from '../../../../config/FieldConfigs';
 import { type OptionInputFieldArgument } from '../../../fieldArguments/inputFieldArguments/arguments/OptionInputFieldArgument';
 import { type OptionQueryInputFieldArgument } from '../../../fieldArguments/inputFieldArguments/arguments/OptionQueryInputFieldArgument';
@@ -58,7 +58,8 @@ export function getSuggesterOptionsForInputField(
 	plugin: MetaBindPlugin,
 ): SuggesterOption<MBLiteral>[] {
 	const app = plugin.app;
-	const dv = getAPI(app);
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+	const dv = (app.plugins.getPlugin('obsidian-dataview') as any).api as DataviewApi | undefined;
 	const optionArgs = inputField.base.getArguments(InputFieldArgumentType.OPTION);
 	const optionQueryArgs = inputField.base.getArguments(InputFieldArgumentType.OPTION_QUERY);
 	const useLinksArgs = inputField.base.getArgument(InputFieldArgumentType.USE_LINKS);

src/fields/viewFields/AbstractViewField.ts

@@ -2,6 +2,7 @@ import { type ViewFieldDeclaration } from '../../parsers/viewFieldParser/ViewFie
 import { type ViewFieldMDRC, type ViewFieldVariable } from '../../renderChildren/ViewFieldMDRC';
 
 import { ViewFieldArgumentType } from '../../config/FieldConfigs';
+import { stringifyUnknown } from '../../utils/Literal';
 
 export abstract class AbstractViewField {
 	protected renderChild: ViewFieldMDRC;
@@ -42,20 +43,10 @@ export abstract class AbstractViewField {
 			return;
 		}
 
-		try {
-			const text = value?.toString() ?? '';
-
-			if (!this.hidden) {
-				this.container.empty();
-				await this._update(this.container, text);
-			}
-			this.container.removeClass('mb-error');
-		} catch (e) {
-			if (e instanceof Error) {
-				console.error(e);
-				this.container.innerText = e.message;
-				this.container.addClass('mb-error');
-			}
+		if (!this.hidden) {
+			const text = stringifyUnknown(value, this.renderChild.plugin.settings.viewFieldDisplayNullAsEmpty) ?? '';
+			this.container.empty();
+			await this._update(this.container, text);
 		}
 	}
 

src/fields/viewFields/fields/MathVF.ts

@@ -2,21 +2,24 @@ import { AbstractViewField } from '../AbstractViewField';
 import { type ViewFieldDeclaration } from '../../../parsers/viewFieldParser/ViewFieldDeclaration';
 import { type ViewFieldMDRC, type ViewFieldVariable } from '../../../renderChildren/ViewFieldMDRC';
 import { ErrorLevel, MetaBindExpressionError } from '../../../utils/errors/MetaBindErrors';
-// import { type EvalFunction, compile as MathJsCompile } from 'mathjs';
 import { Signal } from '../../../utils/Signal';
 import { getUUID } from '../../../utils/Utils';
+import { compile as MathJsCompile, type EvalFunction } from 'mathjs';
 
 export class MathVF extends AbstractViewField {
 	container?: HTMLElement;
-	// expression?: EvalFunction;
+	expression?: EvalFunction;
 	expressionStr?: string;
+	hasError: boolean;
 
 	hidden: boolean;
 
 	constructor(renderChild: ViewFieldMDRC) {
 		super(renderChild);
 
 		this.hidden = false;
+
+		this.hasError = false;
 	}
 
 	public buildVariables(declaration: ViewFieldDeclaration): ViewFieldVariable[] {
@@ -43,15 +46,20 @@ export class MathVF extends AbstractViewField {
 			}
 		}
 
-		// this.expression = MathJsCompile(this.expressionStr);
+		this.expression = MathJsCompile(this.expressionStr);
 
 		return variables;
 	}
 
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	protected _render(container: HTMLElement): void {}
+	protected _render(_container: HTMLElement): void {}
 
 	protected _update(container: HTMLElement, text: string): void {
+		// console.log('hasError', this.hasError);
+		if (this.hasError) {
+			container.addClass('mb-error');
+		} else {
+			container.removeClass('mb-error');
+		}
 		container.innerText = text;
 	}
 
@@ -70,37 +78,51 @@ export class MathVF extends AbstractViewField {
 		return context;
 	}
 
-	async computeValue(variables: ViewFieldVariable[]): Promise<string> {
-		// if (!this.expression) {
-		// 	throw new MetaBindExpressionError({
-		// 		errorLevel: ErrorLevel.ERROR,
-		// 		effect: 'failed to evaluate expression',
-		// 		cause: 'expression is undefined',
-		// 	});
-		// }
+	computeValue(variables: ViewFieldVariable[]): string {
+		this.hasError = false;
+
+		if (!this.expression) {
+			return this.handleComputeError(
+				new MetaBindExpressionError({
+					errorLevel: ErrorLevel.ERROR,
+					effect: 'failed to evaluate expression',
+					cause: 'expression is undefined',
+				}),
+			);
+		}
 
 		const context = this.buildContext(variables);
 		try {
-			// return this.expression.evaluate(context) as Promise<string>;
-			return 'mathjs is disabled';
+			// eslint-disable-next-line
+			return this.expression.evaluate(context).toString();
 		} catch (e) {
 			if (e instanceof Error) {
-				throw new MetaBindExpressionError({
-					errorLevel: ErrorLevel.ERROR,
-					effect: `failed to evaluate expression`,
-					cause: e,
-					context: {
-						expression: this.expressionStr,
-						context: context,
-					},
-				});
+				return this.handleComputeError(
+					new MetaBindExpressionError({
+						errorLevel: ErrorLevel.ERROR,
+						effect: `failed to evaluate expression`,
+						cause: e,
+						context: {
+							expression: this.expressionStr,
+							context: context,
+						},
+					}),
+				);
 			} else {
-				throw new Error('failed to evaluate js expression because of: unexpected thrown value');
+				return this.handleComputeError(
+					new Error('failed to evaluate js expression because of: unexpected thrown value'),
+				);
 			}
 		}
 	}
 
 	public getDefaultDisplayValue(): string {
 		return '';
 	}
+
+	private handleComputeError(e: Error): string {
+		this.hasError = true;
+		console.warn(e);
+		return e.message;
+	}
 }

src/utils/Utils.ts

@@ -124,3 +124,32 @@ export function isUrl(str: string): boolean {
 		return false;
 	}
 }
+
+// inspired by https://stackoverflow.com/a/48764436
+export class DecimalPrecision {
+	static round(value: number, decimalPlaces: number = 0): number {
+		const p = Math.pow(10, decimalPlaces || 0);
+		const n = value * p * (1 + Number.EPSILON);
+		return Math.round(n) / p;
+	}
+
+	static ceil(value: number, decimalPlaces: number = 0): number {
+		const p = Math.pow(10, decimalPlaces || 0);
+		const n = value * p * (1 - Math.sign(value) * Number.EPSILON);
+		return Math.ceil(n) / p;
+	}
+
+	static floor(value: number, decimalPlaces: number = 0): number {
+		const p = Math.pow(10, decimalPlaces || 0);
+		const n = value * p * (1 + Math.sign(value) * Number.EPSILON);
+		return Math.floor(n) / p;
+	}
+
+	static trunc(value: number, decimalPlaces: number = 0): number {
+		return value < 0 ? DecimalPrecision.ceil(value, decimalPlaces) : DecimalPrecision.floor(value, decimalPlaces);
+	}
+
+	static toFixed(value: number, decimalPlaces: number = 0): string {
+		return DecimalPrecision.round(value, decimalPlaces).toFixed(decimalPlaces || 0);
+	}
+}