upgrade chache update algorithm

Author: mProjectsCode

bun.lockb

@@ -57,8 +57,8 @@ Self Loop Error: `VIEW[**{computed}**][text():computed]`
 ## Links
 
 `INPUT[suggester(optionQuery(#example-note), useLinks(false)):file]`
-`VIEW[\[\[{file}|link\]\]][text(renderMarkdown)]`
-`VIEW[{file}][link]`
+link with render markdown: `VIEW[\[\[{file}|link\]\]][text(renderMarkdown)]`
+link with link view field: `VIEW[{file}][link]`
 
 ```meta-bind
 INPUT[imageSuggester(optionQuery("Other/Images")):image]

exampleVault/View Fields/View Field.md

@@ -55,12 +55,12 @@
 	"dependencies": {
 		"@codemirror/legacy-modes": "^6.3.3",
 		"@lemons_dev/parsinom": "^0.0.12",
-		"svelte": "^4.2.11",
-		"itertools-ts": "^1.27.0",
-		"mathjs": "^12.0.0",
+		"itertools-ts": "^1.27.1",
+		"mathjs": "^12.4.1",
+		"moment": "^2.30.1",
+		"svelte": "^4.2.12",
 		"zod": "^3.22.4",
-		"zod-validation-error": "^2.1.0",
-		"moment": "^2.30.1"
+		"zod-validation-error": "^2.1.0"
 	},
 	"private": true
 }

package.json

@@ -125,13 +125,13 @@ export class GlobalMetadataSource implements IMetadataSource<GlobalMetadataCache
 		return this.cache;
 	}
 
-	public updateCache(value: unknown, bindTarget: BindTargetDeclaration): GlobalMetadataCacheItem {
+	public writeCache(value: unknown, bindTarget: BindTargetDeclaration): GlobalMetadataCacheItem {
 		PropUtils.setAndCreate(this.cache.data, bindTarget.storageProp, value);
 
 		return this.cache;
 	}
 
-	public updateEntireCache(value: Metadata, cacheItem: GlobalMetadataCacheItem): void {
+	public writeEntireCache(value: Metadata, cacheItem: GlobalMetadataCacheItem): void {
 		cacheItem.data = value;
 	}
 
@@ -239,15 +239,15 @@ export class ScopeMetadataSource implements IMetadataSource<IMetadataCacheItem>
 		});
 	}
 
-	public updateCache(_value: unknown, _bindTarget: BindTargetDeclaration): IMetadataCacheItem {
+	public writeCache(_value: unknown, _bindTarget: BindTargetDeclaration): IMetadataCacheItem {
 		throw new MetaBindInternalError({
 			errorLevel: ErrorLevel.CRITICAL,
 			effect: 'action not permitted',
 			cause: `source 'scope' should have no cache items or subscriptions`,
 		});
 	}
 
-	public updateEntireCache(_value: Metadata, _cacheItem: IMetadataCacheItem): void {
+	public writeEntireCache(_value: Metadata, _cacheItem: IMetadataCacheItem): void {
 		// noop
 	}
 

packages/core/src/metadata/InternalMetadataSources.ts

@@ -9,12 +9,13 @@ import { type IMetadataSource, type Metadata } from 'packages/core/src/metadata/
 import { MetadataSubscription } from 'packages/core/src/metadata/MetadataSubscription';
 import { type BindTargetDeclaration } from 'packages/core/src/parsers/bindTargetParser/BindTargetDeclaration';
 import { type Signal } from 'packages/core/src/utils/Signal';
-import { areArraysEqual, arrayStartsWith } from 'packages/core/src/utils/Utils';
 import {
 	ErrorLevel,
 	MetaBindBindTargetError,
 	MetaBindInternalError,
 } from 'packages/core/src/utils/errors/MetaBindErrors';
+import { PropUtils } from 'packages/core/src/utils/prop/PropUtils';
+import { type PropPath } from 'packages/core/src/utils/prop/PropPath';
 
 export const METADATA_CACHE_UPDATE_CYCLE_THRESHOLD = 5; // {syncInterval (200)} * 5 = 1s
 export const METADATA_CACHE_INACTIVE_CYCLE_THRESHOLD = 5 * 60; // {syncInterval (200)} * 5 * 60 = 1 minute
@@ -40,34 +41,40 @@ export function hasUpdateOverlap(a: BindTargetDeclaration | undefined, b: BindTa
 		return false;
 	}
 
-	return metadataPathHasUpdateOverlap(
-		a.storageProp.toStringArray(),
-		b.storageProp.toStringArray(),
-		b.listenToChildren,
-	);
+	// TODO: this can be faster, no need to create new arrays
+	return metadataPathHasUpdateOverlap(a.storageProp, b.storageProp, b.listenToChildren);
 }
 
 /**
  * Checks if path `b` should receive an update when path `a` changes.
  * The rules are as follows:
- *  - if they are equal
- *  - if `b` starts with `a` (`a = foo.bar` and `b = foo.bar.baz`)
- *  - if `b` has `listenToChildren` and `a` starts with `b`  (`a = foo.bar.baz` and `b = foo.bar`)
+ *
+ *  - b = foo.bar.baz
+ *      - a = foo.bar -> true
+ *      - a = foo.bar.baz -> true
+ *      - a = foo.bar.baz.baz -> true
+ *      - a = foo.bar.foo -> false
+ *      - a = foo.foo -> false
  *
  * @param a
  * @param b
  * @param listenToChildren whether b listens to updates in children
  */
-export function metadataPathHasUpdateOverlap(a: string[], b: string[], listenToChildren: boolean): boolean {
-	if (areArraysEqual(a, b)) {
-		return true;
+export function metadataPathHasUpdateOverlap(a: PropPath, b: PropPath, listenToChildren: boolean): boolean {
+	const aPath = a.path;
+	const bPath = b.path;
+
+	for (let i = 0; i < Math.min(aPath.length, bPath.length); i++) {
+		if (aPath[i].type !== bPath[i].type || aPath[i].prop !== bPath[i].prop) {
+			return false;
+		}
 	}
 
-	if (arrayStartsWith(b, a)) {
+	if (aPath.length > bPath.length) {
+		return listenToChildren;
+	} else {
 		return true;
 	}
-
-	return listenToChildren && arrayStartsWith(a, b);
 }
 
 export function bindTargetToString(a: BindTargetDeclaration | undefined): string {
@@ -359,12 +366,12 @@ export class MetadataManager {
 		if (source === undefined) {
 			throw new MetaBindInternalError({
 				errorLevel: ErrorLevel.ERROR,
-				effect: 'can not update metadata',
+				effect: 'can not write to cache',
 				cause: `Source "${bindTarget.storageType}" does not exist`,
 			});
 		}
 
-		const cacheItem = source.updateCache(value, bindTarget);
+		const cacheItem = source.writeCache(value, bindTarget);
 		cacheItem.pendingInternalChange = true;
 		cacheItem.cyclesSinceInternalChange = 0;
 		this.notifyListeners(bindTarget, updateSourceUuid);
@@ -431,8 +438,8 @@ export class MetadataManager {
 
 			if (
 				metadataPathHasUpdateOverlap(
-					bindTarget.storageProp.toStringArray(),
-					cacheSubscription.bindTarget.storageProp.toStringArray(),
+					bindTarget.storageProp,
+					cacheSubscription.bindTarget.storageProp,
 					cacheSubscription.bindTarget.listenToChildren,
 				)
 			) {
@@ -501,8 +508,24 @@ export class MetadataManager {
 			return;
 		}
 
-		source.updateEntireCache(value, cacheItem);
-		this.notifyAllListeners(source, cacheItem);
+		const oldValue = source.readEntireCacheItem(cacheItem);
+
+		source.writeEntireCache(value, cacheItem);
+
+		for (const subscription of cacheItem.subscriptions) {
+			if (subscription.bindTarget === undefined) {
+				continue;
+			}
+
+			const propPath = subscription.bindTarget.storageProp;
+
+			const newBoundValue = PropUtils.tryGet(value, propPath);
+			const oldBoundValue = PropUtils.tryGet(oldValue, propPath);
+
+			if (newBoundValue !== oldBoundValue) {
+				subscription.notify(newBoundValue);
+			}
+		}
 	}
 
 	/**

packages/core/src/metadata/MetadataManager.ts

@@ -118,7 +118,7 @@ export interface IMetadataSource<T extends IMetadataCacheItem> {
 	 * @param bindTarget
 	 * @returns The cache item for the bind target.
 	 */
-	updateCache(value: unknown, bindTarget: BindTargetDeclaration): T;
+	writeCache(value: unknown, bindTarget: BindTargetDeclaration): T;
 
 	/**
 	 * Updates the entire cache item with the given value.
@@ -127,7 +127,7 @@ export interface IMetadataSource<T extends IMetadataCacheItem> {
 	 * @param value
 	 * @param cacheItem
 	 */
-	updateEntireCache(value: Metadata, cacheItem: T): void;
+	writeEntireCache(value: Metadata, cacheItem: T): void;
 
 	/**
 	 * Reads the cache item for the given bind target.
@@ -277,15 +277,15 @@ export abstract class FilePathMetadataSource<T extends FilePathMetadataCacheItem
 
 	abstract syncExternal(cacheItem: T): void;
 
-	updateCache(value: unknown, bindTarget: BindTargetDeclaration): T {
+	writeCache(value: unknown, bindTarget: BindTargetDeclaration): T {
 		const cacheItem = this.getOrCreateCacheItem(bindTarget.storagePath);
 
 		PropUtils.setAndCreate(cacheItem.data, bindTarget.storageProp, value);
 
 		return cacheItem;
 	}
 
-	updateEntireCache(value: Metadata, cacheItem: T): void {
+	writeEntireCache(value: Metadata, cacheItem: T): void {
 		cacheItem.data = value;
 	}
 

packages/core/src/metadata/MetadataSource.ts

@@ -93,4 +93,19 @@ export class PropPath {
 	concat(path: PropPath): PropPath {
 		return new PropPath(this.path.concat(path.path));
 	}
+
+	compareDiffArray(path: (string | number)[]): boolean {
+		const len = Math.min(this.path.length, path.length);
+
+		for (let i = 0; i < len; i++) {
+			const access = this.path[i];
+			const pathElement = path[i];
+
+			if (access.prop !== pathElement.toString()) {
+				return false;
+			}
+		}
+
+		return true;
+	}
 }

packages/core/src/utils/prop/PropPath.ts

@@ -151,7 +151,7 @@ export class TestPlugin implements IPlugin {
 		return this.testInputFields.map(x => x.field.getDefaultValue());
 	}
 
-	getAllTestInputFieldSpys(): unknown[] {
+	getAllTestInputFieldSpys(): Mock<(value: any) => void>[] {
 		return this.testInputFields.map(x => x.fieldSignalSetSpy);
 	}
 
@@ -169,6 +169,16 @@ export class TestPlugin implements IPlugin {
 		}
 	}
 
+	expectAllTestInputFieldSpysToHaveBeenCalledTimesOrLess(times: number[]): void {
+		if (times.length !== this.testInputFields.length) {
+			throw new Error('Invalid times length');
+		}
+
+		for (const [spy, time] of this.getAllTestInputFieldSpys().map((x, i) => [x, times[i]] as const)) {
+			expect(spy.mock.calls.length).toBeLessThanOrEqual(time);
+		}
+	}
+
 	expectAllTestInputFieldValuesToEqual(values: any[]): void {
 		if (values.length !== this.testInputFields.length) {
 			throw new Error('Invalid values length');

tests/__mocks__/TestPlugin.ts

@@ -8,4 +8,6 @@ GlobalRegistrator.register({
 if (process.env.LOG_TESTS === 'false') {
 	console.log = () => {};
 	console.debug = () => {};
+} else {
+	console.debug = () => {};
 }

tests/__preload__/happydom.ts

@@ -536,8 +536,8 @@ describe('IPF', () => {
 
 						// check that the input field value is the default value of the IPF, since the front-matter value is invalid
 						testPlugin.expectAllTestInputFieldValuesToEqual([DEFAULT_VALUE_INDICATOR]);
-						// check that the value of the IPF has only been set once
-						testPlugin.expectAllTestInputFieldSpysToHaveBeenCalledTimes([1]);
+						// check that the value of the IPF has only been set once or less, if the value is equal to the default value
+						testPlugin.expectAllTestInputFieldSpysToHaveBeenCalledTimesOrLess([1]);
 						// check that the input field did not update the metadata manager
 						testPlugin.expectMetadataManagerToHaveUpdatedTimes(0);
 					});