fix #589; fix globalMetadata unloading; other minor things

Author: mProjectsCode

automation/build/esbuild.dev.config.ts

@@ -30,7 +30,9 @@ const context = await esbuild.context({
 	format: 'cjs',
 	target: 'es2022',
 	logLevel: 'info',
-	sourcemap: 'inline',
+	sourcemap: false,
+	// NOTE: disabled because some stupid invalid sourcemap warnings
+	// sourcemap: 'inline',
 	treeShaking: true,
 	outdir: `exampleVault/.obsidian/plugins/${manifest.id}/`,
 	outbase: 'packages/obsidian/src',

bun.lock

@@ -35,10 +35,10 @@
 		"@types/bun": "^1.2.18",
 		"builtin-modules": "^5.0.0",
 		"elysia": "^1.3.5",
-		"esbuild": "^0.25.5",
+		"esbuild": "^0.25.6",
 		"esbuild-plugin-copy-watch": "^2.3.1",
 		"esbuild-svelte": "^0.9.3",
-		"eslint": "^9.30.1",
+		"eslint": "^9.31.0",
 		"eslint-plugin-import": "^2.32.0",
 		"eslint-plugin-isaacscript": "^4.0.0",
 		"eslint-plugin-no-relative-import-paths": "^1.6.1",
@@ -51,7 +51,7 @@
 		"svelte-check": "^4.2.2",
 		"tslib": "^2.8.1",
 		"typescript": "^5.8.3",
-		"typescript-eslint": "^8.35.1",
+		"typescript-eslint": "^8.36.0",
 		"yaml": "^2.8.0"
 	},
 	"dependencies": {
@@ -60,9 +60,8 @@
 		"itertools-ts": "^2.2.0",
 		"mathjs": "^14.5.3",
 		"moment": "^2.30.1",
-		"svelte": "^5.35.2",
-		"zod": "^3.25.75",
-		"zod-validation-error": "^3.5.2"
+		"svelte": "^5.35.6",
+		"zod": "^4.0.5"
 	},
 	"private": true,
 	"trustedDependencies": [

package.json

@@ -51,7 +51,7 @@ import { ErrorLevel, MetaBindInternalError } from 'packages/core/src/utils/error
 import { parsePropPath } from 'packages/core/src/utils/prop/PropParser';
 import { Signal } from 'packages/core/src/utils/Signal';
 import { expectType, getUUID } from 'packages/core/src/utils/Utils';
-import { validateAPIArgs } from 'packages/core/src/utils/ZodUtils';
+import { validateAPIArgs, zodFunction } from 'packages/core/src/utils/ZodUtils';
 import { z } from 'zod';
 import type { MB_Comps, MetaBind } from '..';
 
@@ -713,7 +713,7 @@ export abstract class API<Components extends MB_Comps> {
 		validateAPIArgs(
 			z.object({
 				bindTarget: V_BindTargetDeclaration,
-				updateFn: z.function().args(z.any()).returns(z.any()),
+				updateFn: zodFunction<(value: unknown) => unknown>(),
 			}),
 			{
 				bindTarget: bindTarget,
@@ -749,7 +749,7 @@ export abstract class API<Components extends MB_Comps> {
 			z.object({
 				bindTarget: V_BindTargetDeclaration,
 				lifecycleHook: this.mb.internal.getLifecycleHookValidator(),
-				callback: z.function().args(z.any()).returns(z.void()),
+				callback: zodFunction<(value: unknown) => void>(),
 			}),
 			{
 				bindTarget: bindTarget,

packages/core/src/api/API.ts

@@ -21,33 +21,54 @@ import { oneOf, schemaForType } from 'packages/core/src/utils/ZodUtils';
 import { z } from 'zod';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function actionFieldNumber(action: string, name: string, description: string) {
+function actionFieldNumber(action: string, field: 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.`,
+		error: issue => {
+			if (issue.input === undefined) {
+				return `The ${action} action requires a specified ${description} with the '${field}' field.`;
+			} else {
+				return `The ${action} action requires the value of the '${field}' fields to be a number, but got ${typeof issue.input}.`;
+			}
+		},
 	});
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function actionFieldString(action: string, name: string, description: string) {
+function actionFieldString(action: string, field: string, description: string) {
 	return z.string({
-		required_error: `The ${action} action requires a specified ${description} with the '${name}' field.`,
+		error: issue => {
+			if (issue.input === undefined) {
+				return `The ${action} action requires a specified ${description} with the '${field}' field.`;
+			} else {
+				return `The ${action} action requires the value of the '${field}' fields to be a string, but got ${typeof issue.input}.`;
+			}
+		},
 	});
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function actionFieldCoerceString(action: string, name: string, description: string) {
+function actionFieldCoerceString(action: string, field: string, description: string) {
 	return z.coerce.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.`,
+		error: issue => {
+			if (issue.input === undefined) {
+				return `The ${action} action requires a specified ${description} with the '${field}' field.`;
+			} else {
+				return `The ${action} action requires the value of the '${field}' fields to be a string, but got ${typeof issue.input}.`;
+			}
+		},
 	});
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function actionFieldBool(action: string, name: string, description: string) {
+function actionFieldBool(action: string, field: string, description: string) {
 	return z.boolean({
-		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 boolean.`,
+		error: issue => {
+			if (issue.input === undefined) {
+				return `The ${action} action requires a specified ${description} with the '${field}' field.`;
+			} else {
+				return `The ${action} action requires the value of the '${field}' fields to be a boolean, but got ${typeof issue.input}.`;
+			}
+		},
 	});
 }
 
@@ -62,7 +83,7 @@ export const V_JSButtonAction = schemaForType<JSButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.JS),
 		file: actionFieldString('js', 'file', 'file path to the file to run'),
-		args: z.record(z.unknown()).optional(),
+		args: z.record(z.string(), z.unknown()).optional(),
 	}),
 );
 
@@ -120,10 +141,7 @@ export const V_UpdateMetadataButtonAction = schemaForType<UpdateMetadataButtonAc
 			'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.`,
-		}),
+		value: actionFieldCoerceString('updateMetadata', 'value for the update', 'value'),
 	}),
 );
 
@@ -185,7 +203,7 @@ export const V_InlineJSButtonAction = schemaForType<InlineJSButtonAction>()(
 	z.object({
 		type: z.literal(ButtonActionType.INLINE_JS),
 		code: actionFieldString('inlineJS', 'code', 'code string to run'),
-		args: z.record(z.unknown()).optional(),
+		args: z.record(z.string(), z.unknown()).optional(),
 	}),
 );
 
@@ -225,5 +243,5 @@ export const V_ButtonConfig = schemaForType<ButtonConfig>()(
 			action: V_ButtonAction.optional(),
 			actions: V_ButtonAction.array().optional(),
 		})
-		.superRefine(oneOf('action', 'actions')),
+		.check(oneOf('action', 'actions')),
 );

packages/core/src/config/validators/ButtonConfigValidators.ts

@@ -37,7 +37,7 @@ import { Mountable } from 'packages/core/src/utils/Mountable';
 import { PropAccessType } from 'packages/core/src/utils/prop/PropAccess';
 import { PropPath } from 'packages/core/src/utils/prop/PropPath';
 import { Signal } from 'packages/core/src/utils/Signal';
-import { schemaForType } from 'packages/core/src/utils/ZodUtils';
+import { schemaForType, zodFunction } from 'packages/core/src/utils/ZodUtils';
 import { z } from 'zod';
 
 export const V_FilePath = schemaForType<string>()(z.string());
@@ -54,7 +54,7 @@ export const V_BindTargetScope = schemaForType<BindTargetScope>()(z.instanceof(B
 
 export const V_Signal = schemaForType<Signal<unknown>>()(z.instanceof(Signal));
 
-export const V_VoidFunction = schemaForType<() => void>()(z.function().args().returns(z.void()));
+export const V_VoidFunction = schemaForType<() => void>()(zodFunction<() => void>());
 
 export const V_FieldMountable = schemaForType<FieldMountable>()(z.instanceof(FieldMountable));
 export const V_Mountable = schemaForType<Mountable>()(z.instanceof(Mountable));

packages/core/src/config/validators/Validators.ts

@@ -28,8 +28,8 @@ export class InternalMetadataSource extends FilePathMetadataSource<FilePathMetad
 		};
 	}
 
-	public syncExternal(_cacheItem: FilePathMetadataCacheItem): void {
-		// Do nothing
+	public syncExternal(_cacheItem: FilePathMetadataCacheItem): Promise<void> {
+		return Promise.resolve();
 	}
 }
 
@@ -55,8 +55,9 @@ export class TestMetadataSource extends FilePathMetadataSource<FilePathMetadataC
 		};
 	}
 
-	public syncExternal(cacheItem: FilePathMetadataCacheItem): void {
+	public syncExternal(cacheItem: FilePathMetadataCacheItem): Promise<void> {
 		this.externalMetadata[cacheItem.storagePath] = cacheItem.data;
+		return Promise.resolve();
 	}
 }
 
@@ -102,11 +103,11 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 	}
 
 	public getCacheItemForStoragePath(_storagePath: string): GlobalMetadataCacheItem | undefined {
-		return this.cache;
+		return undefined;
 	}
 
-	public iterateCacheItems(): IterableIterator<GlobalMetadataCacheItem> {
-		return [this.cache][Symbol.iterator]();
+	public getCacheItems(): GlobalMetadataCacheItem[] {
+		return [this.cache];
 	}
 
 	public onCycle(_cacheItem: GlobalMetadataCacheItem): void {
@@ -131,8 +132,8 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 		return this.cache;
 	}
 
-	public syncExternal(_cacheItem: GlobalMetadataCacheItem): void {
-		// noop
+	public syncExternal(_cacheItem: GlobalMetadataCacheItem): Promise<void> {
+		return Promise.resolve();
 	}
 
 	public unsubscribe(subscription: IMetadataSubscription): GlobalMetadataCacheItem {
@@ -199,8 +200,8 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 		return undefined;
 	}
 
-	public iterateCacheItems(): IterableIterator<IMetadataCacheItem> {
-		return [][Symbol.iterator]();
+	public getCacheItems(): IMetadataCacheItem[] {
+		return [];
 	}
 
 	public onCycle(_cacheItem: IMetadataCacheItem): void {
@@ -227,8 +228,8 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 		});
 	}
 
-	public syncExternal(_cacheItem: IMetadataCacheItem): void {
-		// noop
+	public syncExternal(_cacheItem: IMetadataCacheItem): Promise<void> {
+		return Promise.resolve();
 	}
 
 	public unsubscribe(_subscription: IMetadataSubscription): IMetadataCacheItem {

packages/core/src/metadata/InternalMetadataSources.ts

@@ -354,21 +354,31 @@ export class MetadataManager {
 	/**
 	 * Internal update function that runs each cycle.
 	 */
-	public cycle(): void {
-		for (const source of this.sources.values()) {
-			const markedForDelete: IMetadataCacheItem[] = [];
+	public async cycle(): Promise<void> {
+		const results = await Promise.allSettled(this.sources.values().map(source => this.cycleSource(source)));
+
+		for (const result of results) {
+			if (result.status === 'rejected') {
+				console.warn(`meta-bind | MetadataManager >> failed to cycle source`, result.reason);
+			}
+		}
+	}
+
+	private async cycleSource(source: MetadataSource): Promise<void> {
+		const markedForDelete: IMetadataCacheItem[] = [];
 
-			for (const cacheItem of source.iterateCacheItems()) {
+		const results = await Promise.allSettled(
+			source.getCacheItems().map(async cacheItem => {
 				source.onCycle(cacheItem);
 
 				// if the cache is dirty, sync the changes to the external source
 				if (cacheItem.dirty) {
 					try {
-						source.syncExternal(cacheItem);
+						await source.syncExternal(cacheItem);
+						cacheItem.dirty = false;
 					} catch (e) {
 						console.warn(`failed to sync changes to external source for ${source.id}`, e);
 					}
-					cacheItem.dirty = false;
 				}
 				// decrease the external write lock duration
 				if (cacheItem.externalWriteLock > 0) {
@@ -386,10 +396,15 @@ export class MetadataManager {
 				) {
 					markedForDelete.push(cacheItem);
 				}
-			}
+			}),
+		);
 
-			for (const cacheItem of markedForDelete) {
-				source.deleteCache(cacheItem);
+		for (const result of results) {
+			if (result.status === 'rejected') {
+				console.warn(
+					`meta-bind | MetadataManager >> failed to cycle cache item in source ${source.id}`,
+					result.reason,
+				);
 			}
 		}
 	}

packages/core/src/metadata/MetadataManager.ts

@@ -70,9 +70,9 @@ export interface IMetadataSource<T extends IMetadataCacheItem> {
 	onCycle(cacheItem: T): void;
 
 	/**
-	 * Iterates over all cache items.
+	 * Get all cache items as an array, so that it can e.g. be iterated over.
 	 */
-	iterateCacheItems(): IterableIterator<T>;
+	getCacheItems(): T[];
 
 	/**
 	 * Can be used to stop the deletion of a cache item.
@@ -93,7 +93,7 @@ export interface IMetadataSource<T extends IMetadataCacheItem> {
 	 *
 	 * @param cacheItem
 	 */
-	syncExternal(cacheItem: T): void;
+	syncExternal(cacheItem: T): Promise<void>;
 
 	/**
 	 * Updates the cache item with the given value.
@@ -232,8 +232,8 @@ export abstract class FilePathMetadataSource<T extends FilePathMetadataCacheItem
 		// noop
 	}
 
-	iterateCacheItems(): IterableIterator<T> {
-		return this.cache.values();
+	getCacheItems(): T[] {
+		return this.cache.values().toArray();
 	}
 
 	shouldDelete(_cacheItem: T): boolean {
@@ -244,7 +244,7 @@ export abstract class FilePathMetadataSource<T extends FilePathMetadataCacheItem
 		this.cache.delete(cacheItem.storagePath);
 	}
 
-	abstract syncExternal(cacheItem: T): void;
+	abstract syncExternal(cacheItem: T): Promise<void>;
 
 	writeCache(value: unknown, bindTarget: BindTargetDeclaration): T {
 		const cacheItem = this.getOrCreateCacheItem(bindTarget.storagePath);

packages/core/src/metadata/MetadataSource.ts

@@ -2,13 +2,12 @@ import { P_UTILS } from '@lemons_dev/parsinom/lib/ParserUtils';
 import { P } from '@lemons_dev/parsinom/lib/ParsiNOM';
 import type { ButtonConfig } from 'packages/core/src/config/ButtonConfig';
 import { V_ButtonConfig } from 'packages/core/src/config/validators/ButtonConfigValidators';
+import type { MetaBind } from 'packages/core/src/index';
 import { runParser } from 'packages/core/src/parsers/ParsingError';
 import { DocsUtils } from 'packages/core/src/utils/DocsUtils';
 import { ErrorCollection } from 'packages/core/src/utils/errors/ErrorCollection';
 import { ErrorLevel, MetaBindButtonError } from 'packages/core/src/utils/errors/MetaBindErrors';
-import { validate } from 'packages/core/src/utils/ZodUtils';
-import { fromZodError } from 'zod-validation-error';
-import type { MetaBind } from '..';
+import { toReadableError, validate } from 'packages/core/src/utils/ZodUtils';
 
 const P_ButtonGroupDeclaration = P.sequenceMap(
 	(_, b) => b,
@@ -85,18 +84,13 @@ export class ButtonParser {
 		const parsedConfig = validate(V_ButtonConfig, config);
 
 		if (!parsedConfig.success) {
-			const niceError = fromZodError(parsedConfig.error, {
-				unionSeparator: '\nOR ',
-				issueSeparator: ' AND ',
-				prefix: null,
-				includePath: false,
-			});
+			const niceError = toReadableError(parsedConfig.error);
 
 			throw new MetaBindButtonError({
 				errorLevel: ErrorLevel.ERROR,
 				effect: 'The validation for the button config failed.',
 				cause: 'Your button syntax seems to be invalid. Check that your button config follows what is described in the docs.',
-				positionContext: niceError.message,
+				positionContext: niceError,
 				docs: [DocsUtils.linkToButtonConfig()],
 			});
 		}