internal improvements

Author: mProjectsCode

packages/core/src/fields/inputFields/AbstractInputField.ts

@@ -5,7 +5,7 @@ import { InputFieldSvelteWrapper } from 'packages/core/src/fields/inputFields/In
 import type { IPlugin } from 'packages/core/src/IPlugin';
 import type { MetadataSubscription } from 'packages/core/src/metadata/MetadataSubscription';
 import { Mountable } from 'packages/core/src/utils/Mountable';
-import { ComputedSignal, Signal } from 'packages/core/src/utils/Signal';
+import { MappedSignal } from 'packages/core/src/utils/Signal';
 
 export abstract class AbstractInputField<
 	MetadataValueType,
@@ -15,8 +15,7 @@ export abstract class AbstractInputField<
 	readonly plugin: IPlugin;
 	readonly mountable: InputFieldMountable;
 	readonly svelteWrapper: InputFieldSvelteWrapper<ComponentValueType, SvelteExports>;
-	readonly inputSignal: Signal<unknown>;
-	readonly computedSignal: ComputedSignal<unknown, MetadataValueType>;
+	readonly inputSignal: MappedSignal<unknown, MetadataValueType>;
 
 	private metadataSubscription?: MetadataSubscription;
 
@@ -25,14 +24,13 @@ export abstract class AbstractInputField<
 
 		this.mountable = mountable;
 		this.plugin = mountable.plugin;
-		this.inputSignal = new Signal<unknown>(undefined);
 		this.svelteWrapper = new InputFieldSvelteWrapper<ComponentValueType, SvelteExports>(
 			this.plugin,
 			this.getSvelteComponent(),
 		);
 
-		this.computedSignal = new ComputedSignal<unknown, MetadataValueType>(
-			this.inputSignal,
+		this.inputSignal = new MappedSignal<unknown, MetadataValueType>(
+			undefined,
 			(value: unknown): MetadataValueType => {
 				const filteredValue = this.filterValue(value);
 				if (filteredValue !== undefined) {
@@ -44,14 +42,6 @@ export abstract class AbstractInputField<
 		);
 	}
 
-	// TODO: What is this?
-	public destroy(): void {
-		// we don't need to unregister the listener because the component will destroy all listeners on unmount
-		if (this.svelteWrapper.isMounted()) {
-			this.unmount();
-		}
-	}
-
 	protected abstract getSvelteComponent(): InputFieldSvelteComponent<ComponentValueType, SvelteExports>;
 
 	/**
@@ -92,7 +82,7 @@ export abstract class AbstractInputField<
 	 * Get the metadata value that the input field currently has.
 	 */
 	public getValue(): MetadataValueType {
-		return this.computedSignal.get();
+		return this.inputSignal.get();
 	}
 
 	/**
@@ -108,7 +98,7 @@ export abstract class AbstractInputField<
 	 * @param value
 	 */
 	public setValue(value: MetadataValueType): void {
-		this.computedSignal.set(value);
+		this.inputSignal.setDirect(value);
 		this.notifySubscription(value);
 	}
 
@@ -143,22 +133,19 @@ export abstract class AbstractInputField<
 	}
 
 	protected onMount(targetEl: HTMLElement): void {
-		// fix for computed signal possibly not having the correct value, as the class might not have been fully initialized
-		this.inputSignal.set(this.inputSignal.get());
-
-		this.computedSignal.registerListener({
+		this.inputSignal.registerListener({
 			callback: value => this.svelteWrapper.setValue(this.reverseMapValue(value)),
 		});
 
+		this.svelteWrapper.registerListener({
+			callback: value => {
+				this.notifySubscription(this.mapValue(value));
+			},
+		});
+
 		const bindTarget = this.mountable.getBindTarget();
 
 		if (bindTarget) {
-			this.svelteWrapper.registerListener({
-				callback: value => {
-					this.notifySubscription(this.mapValue(value));
-				},
-			});
-
 			this.metadataSubscription = this.mountable.plugin.metadataManager.subscribe(
 				this.mountable.getUuid(),
 				this.inputSignal,
@@ -171,7 +158,7 @@ export abstract class AbstractInputField<
 	}
 
 	protected onUnmount(): void {
-		this.computedSignal.unregisterAllListeners();
+		this.inputSignal.unregisterAllListeners();
 		this.metadataSubscription?.unsubscribe();
 
 		this.svelteWrapper.unmount();

packages/core/src/fields/inputFields/InputFieldMountable.ts

@@ -172,7 +172,7 @@ export class InputFieldMountable extends FieldMountable {
 		MB_DEBUG && console.debug('meta-bind | InputFieldMountable >> unmount', this.declaration);
 		super.onUnmount(targetEl);
 
-		this.inputField?.destroy();
+		this.inputField?.unmount();
 
 		showUnloadedMessage(targetEl, 'input field');
 	}

packages/core/src/metadata/ComputedMetadataSubscription.ts

@@ -3,7 +3,7 @@ import type { MetadataManager } from 'packages/core/src/metadata/MetadataManager
 import type { MetadataSubscription } from 'packages/core/src/metadata/MetadataSubscription';
 import type { BindTargetDeclaration } from 'packages/core/src/parsers/bindTargetParser/BindTargetDeclaration';
 import { ErrorLevel, MetaBindInternalError } from 'packages/core/src/utils/errors/MetaBindErrors';
-import type { Signal } from 'packages/core/src/utils/Signal';
+import type { Signal, Writable } from 'packages/core/src/utils/Signal';
 import { getUUID } from 'packages/core/src/utils/Utils';
 
 // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
@@ -16,7 +16,7 @@ export interface ComputedSubscriptionDependency {
 
 export class ComputedMetadataSubscription implements IMetadataSubscription {
 	readonly uuid: string;
-	readonly callbackSignal: Signal<unknown>;
+	readonly callbackSignal: Writable<unknown>;
 
 	readonly metadataManager: MetadataManager;
 
@@ -32,7 +32,7 @@ export class ComputedMetadataSubscription implements IMetadataSubscription {
 
 	constructor(
 		uuid: string,
-		callbackSignal: Signal<unknown>,
+		callbackSignal: Writable<unknown>,
 		metadataManager: MetadataManager,
 		bindTarget: BindTargetDeclaration | undefined,
 		dependencies: ComputedSubscriptionDependency[],
@@ -74,7 +74,7 @@ export class ComputedMetadataSubscription implements IMetadataSubscription {
 
 	private async computeValue(): Promise<void> {
 		try {
-			const values = this.dependencySubscriptions.map(x => x.callbackSignal.get());
+			const values = this.dependencies.map(x => x.callbackSignal.get());
 			const value = await this.computeFunction(values);
 			this.callbackSignal.set(value);
 			if (this.bindTarget !== undefined) {

packages/core/src/metadata/InternalMetadataSources.ts

@@ -1,4 +1,3 @@
-import type { BindTargetScope } from 'packages/core/src/metadata/BindTargetScope';
 import type { IMetadataSubscription } from 'packages/core/src/metadata/IMetadataSubscription';
 import type {
 	FilePathMetadataCacheItem,
@@ -49,10 +48,6 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 		};
 	}
 
-	public createCacheItem(_storagePath: string): GlobalMetadataCacheItem {
-		return this.cache;
-	}
-
 	public getOrCreateCacheItem(_storagePath: string): GlobalMetadataCacheItem {
 		return this.cache;
 	}
@@ -75,14 +70,6 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 		return '';
 	}
 
-	public resolveBindTargetScope(
-		bindTargetDeclaration: BindTargetDeclaration,
-		_scope: BindTargetScope | undefined,
-		_parser: BindTargetParser,
-	): BindTargetDeclaration {
-		return bindTargetDeclaration;
-	}
-
 	public deleteCache(_cacheItem: GlobalMetadataCacheItem): void {
 		// noop
 	}
@@ -99,8 +86,8 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 		// noop
 	}
 
-	public readCache(_bindTarget: BindTargetDeclaration): unknown {
-		return this.readCacheItem(this.cache, _bindTarget.storageProp);
+	public readCache(bindTarget: BindTargetDeclaration): unknown {
+		return this.readCacheItem(this.cache, bindTarget.storageProp);
 	}
 
 	public readCacheItem(cacheItem: GlobalMetadataCacheItem, propPath: PropPath): unknown {
@@ -113,6 +100,7 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 
 	public subscribe(subscription: IMetadataSubscription): GlobalMetadataCacheItem {
 		this.cache.subscriptions.push(subscription);
+
 		return this.cache;
 	}
 
@@ -150,14 +138,6 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 		this.manager = manager;
 	}
 
-	public createCacheItem(_storagePath: string): IMetadataCacheItem {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
-	}
-
 	public getOrCreateCacheItem(_storagePath: string): IMetadataCacheItem {
 		throw new MetaBindInternalError({
 			errorLevel: ErrorLevel.CRITICAL,
@@ -184,14 +164,6 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 		return '';
 	}
 
-	public resolveBindTargetScope(
-		bindTargetDeclaration: BindTargetDeclaration,
-		scope: BindTargetScope | undefined,
-		parser: BindTargetParser,
-	): BindTargetDeclaration {
-		return parser.resolveScope(bindTargetDeclaration, scope);
-	}
-
 	public deleteCache(_cacheItem: IMetadataCacheItem): void {
 		// noop
 	}

packages/core/src/metadata/MetadataCacheItem.ts

@@ -7,19 +7,15 @@ export interface IMetadataCacheItem {
 	/**
 	 * The cycles since the last change to the cache by the plugin.
 	 */
-	cyclesSinceInternalChange: number;
+	externalWriteLock: number;
 	/**
 	 * Whether the cache was changed by the plugin. If this is true, the frontmatter should be updated.
 	 */
-	pendingInternalChange: boolean;
+	dirty: boolean;
 	/**
 	 * The cycles that the cache has been inactive, meaning no listener registered to it.
 	 */
-	cyclesSinceInactive: number;
-	/**
-	 * Whether the there are no subscribers to the cache.
-	 */
-	inactive: boolean;
+	cyclesWithoutListeners: number;
 }
 
 export interface FilePathMetadataCacheItem extends IMetadataCacheItem {

packages/core/src/metadata/MetadataManager.ts

@@ -15,9 +15,9 @@ import {
 } from 'packages/core/src/utils/errors/MetaBindErrors';
 import type { PropPath } from 'packages/core/src/utils/prop/PropPath';
 import { PropUtils } from 'packages/core/src/utils/prop/PropUtils';
-import type { Signal } from 'packages/core/src/utils/Signal';
+import type { Writable } from 'packages/core/src/utils/Signal';
 
-export const METADATA_CACHE_UPDATE_CYCLE_THRESHOLD = 5; // {syncInterval (200)} * 5 = 1s
+export const METADATA_CACHE_EXTERNAL_WRITE_LOCK_DURATION = 5; // {syncInterval (200)} * 5 = 1s
 export const METADATA_CACHE_INACTIVE_CYCLE_THRESHOLD = 5 * 60; // {syncInterval (200)} * 5 * 60 = 1 minute
 
 export type MetadataSource = IMetadataSource<IMetadataCacheItem>;
@@ -124,7 +124,7 @@ export class MetadataManager {
 
 	public subscribe(
 		uuid: string,
-		callbackSignal: Signal<unknown>,
+		callbackSignal: Writable<unknown>,
 		bindTarget: BindTargetDeclaration,
 		onDelete: () => void,
 	): MetadataSubscription {
@@ -153,7 +153,7 @@ export class MetadataManager {
 	 */
 	public subscribeComputed(
 		uuid: string,
-		callbackSignal: Signal<unknown>,
+		callbackSignal: Writable<unknown>,
 		bindTarget: BindTargetDeclaration | undefined,
 		dependencies: ComputedSubscriptionDependency[],
 		computeFunction: ComputeFunction,
@@ -194,7 +194,7 @@ export class MetadataManager {
 
 		const cacheItem = source.unsubscribe(subscription);
 		if (cacheItem.subscriptions.length === 0) {
-			cacheItem.inactive = true;
+			cacheItem.cyclesWithoutListeners = 0;
 		}
 	}
 
@@ -213,8 +213,7 @@ export class MetadataManager {
 		}
 
 		const cacheItem = source.subscribe(subscription);
-		cacheItem.inactive = false;
-		cacheItem.cyclesSinceInactive = 0;
+		cacheItem.cyclesWithoutListeners = 0;
 
 		subscription.notify(source.readCacheItem(cacheItem, subscription.bindTarget.storageProp));
 	}
@@ -326,21 +325,27 @@ export class MetadataManager {
 			for (const cacheItem of source.iterateCacheItems()) {
 				source.onCycle(cacheItem);
 
-				if (cacheItem.pendingInternalChange) {
+				// if the cache is dirty, sync the changes to the external source
+				if (cacheItem.dirty) {
 					try {
 						source.syncExternal(cacheItem);
 					} catch (e) {
-						console.warn('failed to update frontmatter', e);
+						console.warn(`failed to sync changes to external source for ${source.id}`, e);
 					}
-					cacheItem.pendingInternalChange = false;
+					cacheItem.dirty = false;
+				}
+				// decrease the external write lock duration
+				if (cacheItem.externalWriteLock > 0) {
+					cacheItem.externalWriteLock -= 1;
 				}
-				cacheItem.cyclesSinceInternalChange += 1;
 
-				if (cacheItem.inactive) {
-					cacheItem.cyclesSinceInactive += 1;
+				// if there are no listeners, increase the cycles without listeners
+				if (cacheItem.subscriptions.length > 0) {
+					cacheItem.cyclesWithoutListeners += 1;
 				}
+				// if the cache is inactive, check if it should be deleted
 				if (
-					cacheItem.cyclesSinceInactive > METADATA_CACHE_INACTIVE_CYCLE_THRESHOLD &&
+					cacheItem.cyclesWithoutListeners > METADATA_CACHE_INACTIVE_CYCLE_THRESHOLD &&
 					source.shouldDelete(cacheItem)
 				) {
 					markedForDelete.push(cacheItem);
@@ -372,8 +377,8 @@ export class MetadataManager {
 		}
 
 		const cacheItem = source.writeCache(value, bindTarget);
-		cacheItem.pendingInternalChange = true;
-		cacheItem.cyclesSinceInternalChange = 0;
+		cacheItem.dirty = true;
+		cacheItem.externalWriteLock = METADATA_CACHE_EXTERNAL_WRITE_LOCK_DURATION;
 		this.notifyListeners(bindTarget, updateSourceUuid);
 	}
 
@@ -402,7 +407,7 @@ export class MetadataManager {
 	 * @param cacheItem
 	 */
 	public isCacheExternalWriteLocked(cacheItem: IMetadataCacheItem): boolean {
-		return cacheItem.cyclesSinceInternalChange < METADATA_CACHE_UPDATE_CYCLE_THRESHOLD;
+		return cacheItem.externalWriteLock > 0;
 	}
 
 	/**
@@ -485,10 +490,9 @@ export class MetadataManager {
 	public getDefaultCacheItem(): IMetadataCacheItem {
 		return {
 			subscriptions: [],
-			cyclesSinceInternalChange: METADATA_CACHE_UPDATE_CYCLE_THRESHOLD + 1,
-			pendingInternalChange: false,
-			cyclesSinceInactive: 0,
-			inactive: true,
+			externalWriteLock: 0,
+			dirty: false,
+			cyclesWithoutListeners: 0,
 		};
 	}