fix #207 and other small things

Author: mProjectsCode

src/fields/button/ButtonManager.ts

@@ -2,9 +2,12 @@ import { type ButtonConfig } from '../../config/ButtonConfig';
 import { getUUID } from '../../utils/Utils';
 import { ErrorCollection } from '../../utils/errors/ErrorCollection';
 import { ErrorLevel, MetaBindButtonError } from '../../utils/errors/MetaBindErrors';
+import { RefCounter } from '../../utils/RefCounter';
 
 export class ButtonManager {
-	buttons: Map<string, Map<string, ButtonConfig>>;
+	// filePath -> buttonId -> ref counter of buttonConfig
+	buttons: Map<string, Map<string, RefCounter<ButtonConfig>>>;
+	// filePath -> buttonId -> listenerId -> callback
 	buttonLoadListeners: Map<string, Map<string, Map<string, (config: ButtonConfig) => void>>>;
 	buttonTemplates: Map<string, ButtonConfig>;
 
@@ -89,34 +92,37 @@ export class ButtonManager {
 			throw new Error(`ButtonManager | button with id ${buttonId} does not exist`);
 		}
 
-		const fileButtonLoadListeners = this.buttonLoadListeners.get(filePath);
-		if (!fileButtonLoadListeners) {
+		const fileLoadListeners = this.buttonLoadListeners.get(filePath);
+		if (!fileLoadListeners) {
 			return;
 		}
 
-		const buttonLoadListeners = fileButtonLoadListeners.get(buttonId);
-		if (!buttonLoadListeners) {
+		const loadListeners = fileLoadListeners.get(buttonId);
+		if (!loadListeners) {
 			return;
 		}
 
-		for (const [_, fileButtonLoadListener] of buttonLoadListeners) {
+		for (const [_, fileButtonLoadListener] of loadListeners) {
 			fileButtonLoadListener(config);
 		}
 	}
 
 	private removeButtonLoadListener(filePath: string, buttonId: string, listenerId: string): void {
-		const fileButtonLoadListeners = this.buttonLoadListeners.get(filePath);
-		if (!fileButtonLoadListeners) {
+		const fileLoadListeners = this.buttonLoadListeners.get(filePath);
+		if (!fileLoadListeners) {
 			return;
 		}
 
-		const buttonLoadListeners = fileButtonLoadListeners.get(buttonId);
-		if (!buttonLoadListeners) {
+		const loadListeners = fileLoadListeners.get(buttonId);
+		if (!loadListeners) {
 			return;
 		}
 
-		buttonLoadListeners.delete(listenerId);
-		if (fileButtonLoadListeners.size === 0) {
+		loadListeners.delete(listenerId);
+		if (loadListeners.size === 0) {
+			fileLoadListeners.delete(buttonId);
+		}
+		if (fileLoadListeners.size === 0) {
 			this.buttonLoadListeners.delete(filePath);
 		}
 	}
@@ -137,33 +143,37 @@ export class ButtonManager {
 		const fileButtons = this.buttons.get(filePath)!;
 
 		if (fileButtons.has(button.id)) {
-			throw new Error(`ButtonManager | button with id "${button.id}" already exists`);
+			if (JSON.stringify(fileButtons.get(button.id)?.getValue()) === JSON.stringify(button)) {
+				fileButtons.get(button.id)?.increment();
+				return;
+			} else {
+				throw new Error(`ButtonManager | button with id "${button.id}" already exists`);
+			}
 		}
 
-		fileButtons.set(button.id, button);
+		fileButtons.set(button.id, new RefCounter(button));
 		this.notifyButtonLoadListeners(filePath, button.id);
 	}
 
-	public getButtons(filePath: string): Map<string, ButtonConfig> | undefined {
-		return this.buttons.get(filePath);
-	}
-
 	public getButton(filePath: string, buttonId: string): ButtonConfig | undefined {
 		if (this.buttonTemplates.has(buttonId)) {
 			return this.buttonTemplates.get(buttonId);
 		}
 
 		const fileButtons = this.buttons.get(filePath);
 		if (fileButtons) {
-			return fileButtons.get(buttonId);
+			return fileButtons.get(buttonId)?.getValue();
 		}
 		return undefined;
 	}
 
 	public removeButton(filePath: string, buttonId: string): void {
 		const fileButtons = this.buttons.get(filePath);
 		if (fileButtons) {
-			fileButtons.delete(buttonId);
+			fileButtons.get(buttonId)?.decrement();
+			if (fileButtons.get(buttonId)?.isEmpty()) {
+				fileButtons.delete(buttonId);
+			}
 
 			if (fileButtons.size === 0) {
 				this.buttons.delete(filePath);

src/main.ts

@@ -173,7 +173,7 @@ export default class MetaBindPlugin extends Plugin implements IPlugin {
 				if (mdrcType === undefined) {
 					continue;
 				}
-				console.log(content, ctx.getSectionInfo(codeBlock)?.lineStart, ctx.getSectionInfo(codeBlock)?.lineEnd);
+				// console.log(content, ctx.getSectionInfo(codeBlock)?.lineStart, ctx.getSectionInfo(codeBlock)?.lineEnd);
 				InlineMDRCUtils.constructMDRC(mdrcType, content, ctx.sourcePath, codeBlock, ctx, this);
 			}
 		}, 1);

src/metadata/InternalMetadataSources.ts

@@ -172,19 +172,11 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 	}
 
 	public delete(_cacheItem: IMetadataCacheItem): void {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
+		// noop
 	}
 
 	public getCacheItemForStoragePath(_storagePath: string): IMetadataCacheItem | undefined {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
+		return undefined;
 	}
 
 	public iterateCacheItems(): IterableIterator<IMetadataCacheItem> {
@@ -196,27 +188,15 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 	}
 
 	public readCache(_bindTarget: BindTargetDeclaration): unknown {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
+		return undefined;
 	}
 
 	public readCacheItem(_cacheItem: IMetadataCacheItem, _propPath: PropPath): unknown {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
+		return undefined;
 	}
 
 	public shouldDelete(_cacheItem: IMetadataCacheItem): boolean {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
+		return true;
 	}
 
 	public subscribe(_subscription: IMetadataSubscription): IMetadataCacheItem {
@@ -248,11 +228,7 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 	}
 
 	public updateEntireCache(_value: Metadata, _cacheItem: IMetadataCacheItem): void {
-		throw new MetaBindInternalError({
-			errorLevel: ErrorLevel.CRITICAL,
-			effect: 'action not permitted',
-			cause: `source 'scope' should have no cache items or subscriptions`,
-		});
+		// noop
 	}
 
 	public readEntireCacheItem(_cacheItem: IMetadataCacheItem): Metadata {

src/utils/RefCounter.ts

@@ -0,0 +1,31 @@
+export class RefCounter<T> {
+	private readonly value: T;
+	private count: number;
+
+	constructor(value: T) {
+		this.value = value;
+		this.count = 1;
+	}
+
+	getValue(): T {
+		return this.value;
+	}
+
+	increment(): number {
+		this.count += 1;
+		return this.count;
+	}
+
+	decrement(): number {
+		this.count -= 1;
+		return this.count;
+	}
+
+	getCount(): number {
+		return this.count;
+	}
+
+	isEmpty(): boolean {
+		return this.count === 0;
+	}
+}