Everything works

Author: Pckool

packages/plexus-core/src/collection/collection.ts

@@ -320,13 +320,13 @@ export class CollectionInstance<
 			// 		`Batching an collect call for collection ${this.instanceId}`
 			// 	)
 			// 	// store this in the batchedSetters for execution once batching is over
-			// 	this.instance().runtime.batchedCalls.push(() => {
-			// 		this.instance().runtime.log(
-			// 			'debug',
-			// 			`Batched collect call fulfilled for collection ${this.instanceId}`
-			// 		)
-			// 		return collectFn(dataToCollect, groups, true)
-			// 	})
+			// 	// this.instance().runtime.batchedCalls.push(() => {
+			// 	// 	this.instance().runtime.log(
+			// 	// 		'debug',
+			// 	// 		`Batched collect call fulfilled for collection ${this.instanceId}`
+			// 	// 	)
+			// 	// 	return collectFn(dataToCollect, groups, true)
+			// 	// })
 			// 	return this
 			// }
 
@@ -787,19 +787,15 @@ export class CollectionInstance<
 	 * @returns {this} The new Collection Instance
 	 */
 	delete(keys: DataKey | DataKey[]): this {
-		// the function to remove the data
-		const rm = (key: DataKey) => {
+		// if an array, iterate through the keys and remove them each
+		keys = Array.isArray(keys) ? keys : [keys]
+		for (let key of keys) {
 			// key = this.config.keyTransform(key)
 			key = `${key}`
 			this._internalStore._data.get(key)?.clean()
 			this.removeFromGroups(key, this.getGroupsOf(key))
 			this._internalStore._data.delete(key)
 		}
-		// if an array, iterate through the keys and remove them each
-		keys = Array.isArray(keys) ? keys : [keys]
-		for (const key of keys) {
-			rm(key)
-		}
 		this.mount()
 		return this
 	}
@@ -834,21 +830,18 @@ export class CollectionInstance<
 		if (!keys.length || !groups.length) return this
 
 		this.mount()
-		const rm = (key) => {
-			key = `${key}`
-			for (let groupName of groups) {
-				if (this.isCreatedGroup(groupName)) {
-					this._internalStore._groups.get(groupName)?.remove(key)
-				}
-			}
-		}
 
 		// if an array, iterate through the keys and remove them from each associated group
 		// this.instance().runtime.engine.halt()
 		// const release = this.instance().runtime.engine.halt()
 		this.instance().runtime.batch(() => {
 			for (let key of keys) {
-				rm(key)
+				key = `${key}`
+				for (let groupName of groups) {
+					if (this.isCreatedGroup(groupName)) {
+						this._internalStore._groups.get(groupName)?.remove(key)
+					}
+				}
 			}
 		})
 		return this

packages/plexus-core/src/collection/group.ts

@@ -28,7 +28,7 @@ interface CollectionGroupStore<DataType = any> {
  * A group of data
  */
 export class CollectionGroup<
-	DataType extends Record<string, any> = any,
+	DataType extends Record<string, any> = any
 > extends Watchable<DataType[]> {
 	private _internalStore: CollectionGroupStore<DataType>
 	private collection: () => PlexusCollectionInstance<DataType>
@@ -85,6 +85,7 @@ export class CollectionGroup<
 		this.instance().runtime.broadcast(this.id, this.value)
 	}
 	private rebuildDataWatchers(startedFromInnerBatch?: boolean) {
+		// this.instance().runtime.batch(() => {
 		this.instance().runtime.log(
 			'info',
 			`Group ${this.instanceId} rebuilding data watcher connections...`
@@ -106,6 +107,7 @@ export class CollectionGroup<
 		if (destroyer) this._internalStore._dataWatcherDestroyers.add(destroyer)
 
 		this.runWatchers()
+		// })
 	}
 	/**
 	 * Check if the group contains the given item
@@ -142,7 +144,9 @@ export class CollectionGroup<
 			this._internalStore._includedKeys.add(key)
 		}
 		if (newKeysAdded) {
+			// this.instance().runtime.batch(() => {
 			this.rebuildDataWatchers()
+			// })
 		}
 		return this
 	}

packages/plexus-core/src/instance/engine.ts

@@ -7,7 +7,8 @@ export interface EngineEventReceiver {
 
 type EventPayload = { key: String; value: any }
 export class EventEngine {
-	private batching: boolean = false
+	private halted: boolean = false
+	private halts: number = 0
 	events: Map<string, Array<EngineEventReceiver>>
 	pendingEventPayloads: Map<string, EventPayload>
 
@@ -20,24 +21,30 @@ export class EventEngine {
 	 * Pause and store all events until the return function is called. Once called, all events will be emitted.
 	 */
 	halt() {
-		console.log('halting')
-		this.batching = true
+		this.halts++
+		if (!this.halted) console.log('halting engine...')
+
+		this.halted = true
 		return () => this.release()
 	}
 	/**
 	 * Emit all stored concatenated events and resume normal event emitting.
 	 */
 	release() {
-		this.batching = false
+		this.halts--
+		if (this.halts > 0) return () => null
+		this.halted = false
 		if (this.pendingEventPayloads.size === 0) return
 		// if (this.batching === false) return
-		Array.from(this.pendingEventPayloads.entries()).forEach(
-			([eventId, args]) => {
-				console.log('releasing', eventId, args)
-
-				this.emit(eventId, args)
-			}
+		const pendingEntries = Array.from(this.pendingEventPayloads.entries())
+		console.log(
+			`releasing ${pendingEntries.length} (${this.pendingEventPayloads.size}) events`
 		)
+		for (const [eventId, args] of pendingEntries) {
+			console.log(`releasing ${eventId} stored payload`)
+			this.emit(eventId, args)
+		}
+
 		this.pendingEventPayloads.clear()
 	}
 
@@ -101,23 +108,22 @@ export class EventEngine {
 	emit(eventId: string, args: EventPayload) {
 		// this.schedule.addTask(() => {
 		// if we're batching, store the event payload
-		if (this.batching) {
+		if (this.halted) {
 			const pendingPayload = this.pendingEventPayloads.get(eventId)
 
 			const eventPayload = pendingPayload
 				? deepMerge<EventPayload>(pendingPayload, args)
 				: args
-			console.log(
-				'Emit occured while batching enabled',
-				eventId,
-				pendingPayload,
-				this.events.get(eventId),
-				eventPayload
-			)
+			// console.log(
+			// 	'Emit occured while batching enabled',
+			// 	eventId,
+			// 	pendingPayload,
+			// 	this.events.get(eventId),
+			// 	eventPayload
+			// )
 			this.pendingEventPayloads.set(eventId, eventPayload)
 			return
 		}
-		console.log('Emitting', eventId, args)
 		// run the event listeners for this event id
 		this.events
 			.get(eventId)

packages/plexus-core/src/instance/instance.ts

@@ -219,6 +219,6 @@ export function instance(
  */
 export function batch<BatchFunction extends () => any | Promise<any> = any>(
 	fn: BatchFunction
-): ReturnType<BatchFunction> {
+): ReturnType<BatchFunction> | null {
 	return instance().runtime.batch(fn)
 }

packages/plexus-core/src/instance/runtime.ts

@@ -26,6 +26,8 @@ export class RuntimeInstance {
 	private initializing = false
 	private initsCompleted = 0
 	private batching: boolean = false
+	// private batchPromise: Promise<any> | null = null
+	private batchesInProgress: number = 0
 	batchedCalls: Array<() => any> = []
 
 	schedule: Scheduler
@@ -213,52 +215,40 @@ export class RuntimeInstance {
 	}
 
 	/**
-	 *	The batch function allows you to run a series of reactive actions in a single transaction
+	 *	The batch function allows you to run a series of reactive actions in a single transaction.
+	 * If there is already a batch in progress, the function will be added to the batch and run when the batch is released.
 	 * @param {Function} fn The function to run
 	 */
 	batch<BatchFunction extends () => any | Promise<any>>(
 		fn: BatchFunction
-	): ReturnType<BatchFunction> {
+	): ReturnType<BatchFunction> | null {
 		if (!fn) {
 			throw new Error('You must provide a function to run in the batch')
 		}
-		// if we are already batching, just run the function
+		// if we are already batching, add the function to the array and return
 		if (this.batching) {
-			return fn()
+			// return fn()
+			console.log('Already batching something, ')
+			// ++this.batchesInProgress
+			this.batchedCalls.push(() => fn())
+			return null
 		}
 
-		this.startBatching()
-		this.instance().runtime.log('info', 'Batch function started!')
-		const releaseBatch = () => {
-			// if we aren't batching anymore, just return
-			if (this.batching === false) {
-				return
-			}
-			// stop storing changes and emit the changes
-			this.batching = false
-			const unhalt = this.engine.halt()
-			// call all the pending functions and clear the array
-			this.batchedCalls.forEach((pendingFn) => pendingFn())
-			this.batchedCalls.length = 0
-
-			// release the reactivity engine
-			unhalt()
+		const release = this.startBatching()
 
-			this.instance().runtime.log('info', 'Batch function completed!')
-		}
 		// run the function. If it returns a promise, wait for it to resolve
 		const pendingResponse = fn()
 		if (pendingResponse instanceof Promise) {
 			return new Promise<ReturnType<BatchFunction>>(async (resolve, reject) => {
 				// wait for the promise to resolve
 				const value = await pendingResponse
 				// release the batch
-				this.endBatching()
+				release()
 				// resolve the promise, return the value of the promise
 				return resolve(value)
 			}) as ReturnType<BatchFunction>
 		}
-		this.endBatching()
+		release()
 		return pendingResponse
 	}
 
@@ -274,31 +264,51 @@ export class RuntimeInstance {
 	 *	Release the batch
 	 * @returns {void}
 	 */
-	endBatching() {
+	private endBatching() {
 		// if we aren't batching anymore, just return
 		if (this.batching === false) {
 			return
 		}
-		// stop storing changes and emit the changes
-		this.batching = false
+		// decrement the number of batches in progress
+		--this.batchesInProgress
+		// if there are still batches in progress, just return
+		if (this.batchesInProgress > 0) {
+			console.log(
+				`Aborting batch end because ${this.batchesInProgress} batches are still in progress`
+			)
+			return
+		}
+
+		const unhalt = this.engine.halt()
+		console.log(`batchedCalls ${this.batchesInProgress}`, this.batchedCalls)
 		// call all the pending functions and clear the array
-		this.batchedCalls.forEach((pendingFn) => pendingFn())
+		this.batching = false
+		const v = this.batchesInProgress
+		for (const pendingFn of this.batchedCalls) {
+			pendingFn()
+			console.log(
+				`Running pending function  with ${this.batchesInProgress} others in progress`
+			)
+		}
+
 		this.batchedCalls.length = 0
 
 		// release the reactivity engine
-		// this.engine.release()
-
+		unhalt()
+		// if(this.batchesInProgress === 0) { unhalt() }
 		this.instance().runtime.log('info', 'Batch function completed!')
 	}
 	/**
 	 * Begin batching any calls to the runtime
 	 * @private
 	 * @returns {Function(): void} A function to release the batch
 	 */
-	startBatching() {
+	private startBatching() {
 		this.batching = true
+		++this.batchesInProgress
 		// hold the reactivity engine and start storing changes
 		// this.engine.halt()
+		this.instance().runtime.log('info', 'Batch function started!')
 		return () => {
 			this.endBatching()
 		}

packages/plexus-core/src/scope.ts

@@ -107,7 +107,7 @@ export class Scope {
 	 */
 	batch<BatchFunction extends () => any | Promise<any> = any>(
 		fn: BatchFunction
-	): ReturnType<BatchFunction> {
+	): ReturnType<BatchFunction> | null {
 		return this.instance().runtime.batch(fn)
 	}
 	/**

packages/plexus-core/src/watchable.ts

@@ -116,7 +116,8 @@ export class WatchableMutable<ValueType = any> extends Watchable<ValueType> {
 	 */
 	set(newValue?: PlexusWatchableValueInterpreter<ValueType>): this {
 		if (this.instance().runtime.isBatching) {
-			this.instance().runtime.batchedCalls.push(() => this.set(newValue))
+			// this.instance().runtime.batchedCalls.push(() => this.set(newValue))
+			this.instance().runtime.batch(() => this.set(newValue))
 			return this
 		}
 		this.loading = true

tests/efficiency.test.ts

@@ -57,16 +57,18 @@ afterEach(() => {
 })
 
 describe('Efficiency tests for ', () => {
-	// test('The speed of a plexus collection collecting more than a thousand randomly generated objects into multiple groups', () => {
-	// 	// instance({ logLevel: 'debug' })
-	// 	console.log('Starting test...')
-	// 	console.log('items in collection:', users1k.length)
-	// 	usersLite.collect(users1k, ['firstNames'])
-	// 	console.log('items in collection:', usersLite.value.length)
-	// 	expect(usersLite.value.length).toBe(1000)
-	// 	expect(usersLite.groups.firstNames.value.length).toBe(1000)
-	// 	// instance({ logLevel: undefined })
-	// })
+	test('The speed of a plexus collection collecting more than a thousand randomly generated objects into multiple groups', () => {
+		instance({ logLevel: 'debug' })
+		console.log('Starting test...')
+		console.log(`${users1k.length} items being pulled into collection`)
+		usersLite.collect(users1k.slice(0, 30), ['firstNames'])
+		// expect(usersLite.size).toBe(1000)
+		console.log('items in collection:', usersLite.size)
+		expect(usersLite.size).toBe(1000)
+		// expect(usersLite.value.length).toBe(1000)
+		// expect(usersLite.groups.firstNames.value.length).toBe(1000)
+		instance({ logLevel: undefined })
+	})
 	// test('Testing the same as above but with an absurd amount of data', () => {
 	// 	// instance({ logLevel: 'debug' })
 	// 	console.log('Starting test...')