better errors second part; fix #311

Author: mProjectsCode

packages/core/src/Settings.ts

@@ -75,9 +75,6 @@ export interface MetaBindPluginSettings {
 	inputFieldTemplates: InputFieldTemplate[];
 	buttonTemplates: ButtonConfig[];
 	excludedFolders: string[];
-
-	// @deprecated
-	inputTemplates: string | undefined;
 }
 
 export interface InputFieldTemplate {
@@ -101,7 +98,4 @@ export const DEFAULT_SETTINGS: MetaBindPluginSettings = {
 	inputFieldTemplates: [],
 	buttonTemplates: [],
 	excludedFolders: ['templates'],
-
-	// @deprecated
-	inputTemplates: undefined,
 };

packages/core/src/config/ButtonConfigValidators.ts

@@ -20,20 +20,23 @@ import {
 import { oneOf, schemaForType } from 'packages/core/src/utils/ZodUtils';
 import { z } from 'zod';
 
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function numberValidator(action: string, name: string, description: string) {
 	return z.number({
 		required_error: `The ${action} action requires a specified ${description} with the '${name}' field.`,
 		invalid_type_error: `The ${action} action requires the value of the '${name}' fields to be a number.`,
 	});
 }
 
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function stringValidator(action: string, name: string, description: string) {
 	return z.string({
 		required_error: `The ${action} action requires a specified ${description} with the '${name}' field.`,
 		invalid_type_error: `The ${action} action requires the value of the '${name}' fields to be a string.`,
 	});
 }
 
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function booleanValidator(action: string, name: string, description: string) {
 	return z.boolean({
 		required_error: `The ${action} action requires a specified ${description} with the '${name}' field.`,
@@ -82,69 +85,76 @@ export const V_SleepButtonAction = schemaForType<SleepButtonAction>()(
 export const V_TemplaterCreateNoteButtonAction = schemaForType<TemplaterCreateNoteButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.TEMPLATER_CREATE_NOTE),
-		templateFile: z.string(),
-		folderPath: z.string().optional(),
-		fileName: z.string().optional(),
-		openNote: z.boolean().optional(),
+		templateFile: stringValidator('templaterCreateNote', 'templateFile', 'template file path'),
+		folderPath: stringValidator('templaterCreateNote', 'folderPath', 'folder path').optional(),
+		fileName: stringValidator('templaterCreateNote', 'fileName', 'file name').optional(),
+		openNote: booleanValidator('templaterCreateNote', 'openNote', 'value for whether to open the note').optional(),
 	}),
 );
 export const V_UpdateMetadataButtonAction = schemaForType<UpdateMetadataButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.UPDATE_METADATA),
-		bindTarget: z.string(),
-		evaluate: z.boolean(),
-		value: z.coerce.string(),
+		bindTarget: stringValidator('updateMetadata', 'bindTarget', 'bind target to the metadata to update'),
+		evaluate: booleanValidator(
+			'updateMetadata',
+			'evaluate',
+			'value for whether to evaluate the value as a JavaScript expression',
+		),
+		value: z.coerce.string({
+			required_error: `The updateMetadata action requires a specified value for the update with the 'value' field.`,
+			invalid_type_error: `The updateMetadata action requires the value of the 'value' fields to be a string.`,
+		}),
 	}),
 );
 
 export const V_CreateNoteButtonAction = schemaForType<CreateNoteButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.CREATE_NOTE),
-		folderPath: z.string().optional(),
-		fileName: z.string(),
-		openNote: z.boolean().optional(),
+		folderPath: stringValidator('createNote', 'folderPath', 'folder path').optional(),
+		fileName: stringValidator('createNote', 'fileName', 'file name'),
+		openNote: booleanValidator('createNote', 'openNote', 'value for whether to open the note').optional(),
 	}),
 );
 
 export const V_ReplaceInNoteButtonAction = schemaForType<ReplaceInNoteButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.REPLACE_IN_NOTE),
-		fromLine: z.number(),
-		toLine: z.number(),
-		replacement: z.string(),
-		templater: z.boolean().optional(),
+		fromLine: numberValidator('replaceInNote', 'fromLine', 'line to replace from'),
+		toLine: numberValidator('replaceInNote', 'toLine', 'line to replace to'),
+		replacement: stringValidator('replaceInNote', 'replacement', 'replacement string'),
+		templater: booleanValidator('replaceInNote', 'templater', 'value for whether to use Templater').optional(),
 	}),
 );
 
 export const V_ReplaceSelfButtonAction = schemaForType<ReplaceSelfButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.REPLACE_SELF),
-		replacement: z.string(),
-		templater: z.boolean().optional(),
+		replacement: stringValidator('replaceSelf', 'replacement', 'replacement string'),
+		templater: booleanValidator('replaceSelf', 'templater', 'value for whether to use Templater').optional(),
 	}),
 );
 
 export const V_RegexpReplaceInNoteButtonAction = schemaForType<RegexpReplaceInNoteButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.REGEXP_REPLACE_IN_NOTE),
-		regexp: z.string(),
-		replacement: z.string(),
+		regexp: stringValidator('regexpReplaceInNote', 'regexp', 'search regular expression'),
+		replacement: stringValidator('regexpReplaceInNote', 'replacement', 'replacement string'),
 	}),
 );
 
 export const V_InsertIntoNoteButtonAction = schemaForType<InsertIntoNoteButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.INSERT_INTO_NOTE),
-		line: z.number(),
-		value: z.string(),
-		templater: z.boolean().optional(),
+		line: numberValidator('insertIntoNote', 'line', 'line to insert at'),
+		value: stringValidator('insertIntoNote', 'value', 'string to insert'),
+		templater: booleanValidator('insertIntoNote', 'templater', 'value for whether to use Templater').optional(),
 	}),
 );
 
 export const V_InlineJsButtonAction = schemaForType<InlineJsButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.INLINE_JS),
-		code: z.string(),
+		code: stringValidator('inlineJS', 'code', 'code string to run'),
 	}),
 );
 

packages/core/src/utils/Utils.ts

@@ -67,6 +67,53 @@ export function areArraysEqual<T>(arr1: T[] | undefined, arr2: T[] | undefined):
 	return true;
 }
 
+export function areObjectsEqual(obj1: unknown, obj2: unknown): boolean {
+	if (obj1 == null && obj2 == null) {
+		return true;
+	}
+	if (obj1 == null || obj2 == null) {
+		return false;
+	}
+
+	if (typeof obj1 !== typeof obj2) {
+		return false;
+	}
+
+	if (typeof obj1 === 'object' && typeof obj2 === 'object') {
+		if (Array.isArray(obj1) && Array.isArray(obj2)) {
+			if (obj1.length !== obj2.length) {
+				return false;
+			}
+
+			for (let i = 0; i < obj1.length; i++) {
+				if (!areObjectsEqual(obj1[i], obj2[i])) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		const keys1 = Object.keys(obj1);
+		const keys2 = Object.keys(obj2);
+
+		if (keys1.length !== keys2.length) {
+			return false;
+		}
+
+		for (const key of keys1) {
+			// @ts-ignore
+			if (!areObjectsEqual(obj1[key], obj2[key])) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	return obj1 === obj2;
+}
+
 /**
  * Checks if arr starts with base.
  *

packages/obsidian/src/cm6/Cm5_Modes.ts

@@ -3,8 +3,7 @@ import { javascript } from '@codemirror/legacy-modes/mode/javascript';
 import { type Mode, type StringStream } from 'codemirror';
 import { SyntaxHighlighting } from 'packages/core/src/parsers/syntaxHighlighting/SyntaxHighlighting';
 import type MetaBindPlugin from 'packages/obsidian/src/main';
-
-import { type FieldType, type InlineFieldType } from 'packages/core/src/config/APIConfigs';
+import { type InlineFieldType } from 'packages/core/src/config/APIConfigs';
 
 export function registerCm5HLModes(plugin: MetaBindPlugin): void {
 	/* eslint-disable */

packages/obsidian/src/main.ts

@@ -24,6 +24,7 @@ import { PlaygroundView, MB_PLAYGROUND_VIEW_TYPE } from 'packages/obsidian/src/p
 import { MetaBindSettingTab } from 'packages/obsidian/src/settings/SettingsTab';
 import { ObsidianNotePosition } from 'packages/obsidian/src/ObsidianNotePosition';
 import { RenderChildType } from 'packages/core/src/config/APIConfigs';
+import { areObjectsEqual } from 'packages/core/src/utils/Utils';
 
 export enum MetaBindBuild {
 	DEV = 'dev',
@@ -341,9 +342,17 @@ export default class MetaBindPlugin extends Plugin implements IPlugin {
 
 		const loadedSettings = (await this.loadData()) as MetaBindPluginSettings;
 
+		// @ts-expect-error TS2339 remove old config field
+		delete loadedSettings.inputTemplates;
+		// @ts-expect-error TS2339 remove old config field
+		delete loadedSettings.useUsDateInputOrder;
+
 		this.settings = Object.assign({}, DEFAULT_SETTINGS, loadedSettings);
 
-		await this.saveSettings();
+		if (!areObjectsEqual(loadedSettings, this.settings)) {
+			// console.log(JSON.stringify(loadedSettings, null, '\t'), JSON.stringify(this.settings, null, '\t'));
+			await this.saveSettings();
+		}
 	}
 
 	async saveSettings(): Promise<void> {