internal systems overhaul init

Author: Pckool

.trunk/trunk.yaml

@@ -1,6 +1,6 @@
 version: 0.1
 cli:
-  version: 1.14.0
+  version: 1.14.2
 plugins:
   sources:
     - id: trunk

docs/docs/api-reference/batch.mdx

@@ -29,7 +29,7 @@ Run a function. During that function's execution, any state changes will be batc
 <a name="RuntimeInstance+batch"></a>
 
 ## .batch(fn)
-<p>The batch function allows you to run a series of actions in a single transaction</p>
+<p>The batch function allows you to run a series of reactive actions in a single transaction</p>
 
 
 | Param | Type | Description |

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

@@ -305,7 +305,7 @@ export class CollectionInstance<
 			return Array.from(addedKeys.values())
 		}
 		const collectFn = (
-			data_: typeof data,
+			dataToCollect: typeof data,
 			groups?: KeyOfMap<Groups>[] | KeyOfMap<Groups>,
 			startedFromInnerBatch?: boolean
 		) => {
@@ -325,13 +325,13 @@ export class CollectionInstance<
 						'debug',
 						`Batched collect call fulfilled for collection ${this.instanceId}`
 					)
-					return collectFn(data_, groups, true)
+					return collectFn(dataToCollect, groups, true)
 				})
 				return this
 			}
 
 			const addedKeys: any[] = collectItems(
-				Array.isArray(data_) ? data_ : [data_]
+				Array.isArray(dataToCollect) ? dataToCollect : [dataToCollect]
 			)
 
 			const defaultGroupName =
@@ -355,12 +355,19 @@ export class CollectionInstance<
 			}
 			this._internalStore._internalCalledGroupCollect = false
 		}
+
 		// we only need to call back if the instance is not batching
 		if (this.config.useBatching) {
+			// this.instance().runtime.startBatching()
 			this.instance().runtime.batch(() => collectFn(data, groups))
 		} else {
 			collectFn(data, groups)
 		}
+
+		// if (this.config.useBatching) {
+		// 	this.instance().runtime.endBatching()
+		// }
+
 		this.mount()
 		return this
 	}
@@ -788,10 +795,29 @@ export class CollectionInstance<
 			this._internalStore._data.delete(key)
 		}
 		// if an array, iterate through the keys and remove them each
-		if (Array.isArray(keys)) {
-			keys.forEach(rm)
-		} else {
-			rm(keys)
+		keys = Array.isArray(keys) ? keys : [keys]
+
+		// if the instance is batching and this collection has batching enabled, add this action to the batchedSetters
+		if (
+			// this.instance().runtime.isBatching &&
+			this.config.useBatching
+		) {
+			this.instance().runtime.log(
+				'debug',
+				`Batching an delete call for collection ${this.instanceId}`
+			)
+			this.instance().runtime.startBatching()
+		}
+		// run this remove call
+		for (const key of keys) {
+			rm(key)
+		}
+		if (this.config.useBatching) {
+			this.instance().runtime.endBatching()
+			this.instance().runtime.log(
+				'debug',
+				`Batched delete call fulfilled for collection ${this.instanceId}`
+			)
 		}
 		this.mount()
 		return this
@@ -836,10 +862,9 @@ export class CollectionInstance<
 		}
 
 		// if an array, iterate through the keys and remove them from each associated group
-		if (Array.isArray(keys)) {
-			keys.forEach(rm)
-		} else {
-			rm(keys)
+		keys = Array.isArray(keys) ? keys : [keys]
+		for (let key of keys) {
+			rm(key)
 		}
 		return this
 		// ! This is commented out because the user may still want to keep the data in the collection. If they want to completely delete the data, they should use `.delete()`
@@ -856,13 +881,9 @@ export class CollectionInstance<
 	clear(groupNames?: KeyOfMap<Groups> | KeyOfMap<Groups>[]): this {
 		// this means we want to clear a group, not the whole collection
 		if (groupNames) {
-			if (Array.isArray(groupNames)) {
-				groupNames.forEach(
-					(groupName) =>
-						this.isCreatedGroup(groupName) && this.getGroup(groupName).clear()
-				)
-			} else {
-				this.isCreatedGroup(groupNames) && this.getGroup(groupNames).clear()
+			groupNames = Array.isArray(groupNames) ? groupNames : [groupNames]
+			for (const groupName of groupNames) {
+				this.isCreatedGroup(groupName) && this.getGroup(groupName).clear()
 			}
 		} else {
 			this.delete(Array.from(this._internalStore._data.keys()))

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

@@ -20,13 +20,19 @@ export class EventEngine {
 	halt() {
 		this.batching = true
 		return () => {
-			this.batching = false
-			this.pendingEventPayloads.forEach((args, eventId) => {
-				this.emit(eventId, args)
-			})
-			this.pendingEventPayloads.clear()
+			this.release()
 		}
 	}
+	/**
+	 * Emit all stored concatenated events and resume normal event emitting.
+	 */
+	release() {
+		this.batching = false
+		this.pendingEventPayloads.forEach((args, eventId) => {
+			this.emit(eventId, args)
+		})
+		this.pendingEventPayloads.clear()
+	}
 
 	on(eventId: string, listener: PlexusInternalWatcher, origin?: string) {
 		if (!eventId || eventId === '') {

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

@@ -213,7 +213,7 @@ export class RuntimeInstance {
 	}
 
 	/**
-	 *	The batch function allows you to run a series of actions in a single transaction
+	 *	The batch function allows you to run a series of reactive actions in a single transaction
 	 * @param {Function} fn The function to run
 	 */
 	batch<BatchFunction extends () => any | Promise<any>>(
@@ -227,40 +227,22 @@ export class RuntimeInstance {
 			return fn()
 		}
 
-		// hold the reactivity engine and start storing changes
-		// const unhalt = this.engine.halt()
-		this.batching = true
+		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
-			// call all the pending functions and clear the array
-			this.batchedCalls.forEach((pendingFn) => pendingFn())
-			this.batchedCalls.length = 0
-
-			// release the reactivity engine
-			// unhalt()
-
-			this.instance().runtime.log('info', 'Batch function completed!')
-		}
 		// run the function. If it returns a promise, wait for it to resolve
-		const prom = fn()
-		if (prom instanceof Promise) {
+		const pendingResponse = fn()
+		if (pendingResponse instanceof Promise) {
 			return new Promise<ReturnType<BatchFunction>>(async (resolve, reject) => {
 				// wait for the promise to resolve
-				const value = await prom
+				const value = await pendingResponse
 				// release the batch
-				releaseBatch()
+				this.endBatching()
 				// resolve the promise, return the value of the promise
 				return resolve(value)
 			}) as ReturnType<BatchFunction>
 		}
-		releaseBatch()
-		return prom
+		this.endBatching()
+		return pendingResponse
 	}
 
 	/**
@@ -270,6 +252,40 @@ export class RuntimeInstance {
 	get isBatching() {
 		return this.batching
 	}
+
+	/**
+	 *	Release the batch
+	 * @returns {void}
+	 */
+	endBatching() {
+		// if we aren't batching anymore, just return
+		if (this.batching === false) {
+			return
+		}
+		// stop storing changes and emit the changes
+		this.batching = false
+		// call all the pending functions and clear the array
+		this.batchedCalls.forEach((pendingFn) => pendingFn())
+		this.batchedCalls.length = 0
+
+		// release the reactivity engine
+		// this.engine.release()
+
+		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() {
+		this.batching = true
+		// hold the reactivity engine and start storing changes
+		// this.engine.halt()
+		return () => {
+			this.endBatching()
+		}
+	}
 }
 /**
  * Create a runtime for an instance NOTE: NOT FOR PUBLIC USE

packages/plexus-core/src/storage.ts

@@ -179,6 +179,7 @@ export class StorageInstance {
 		}
 	}
 
+	// ! This might be broken? Definitely need to rethink storage procedures
 	sync(checkValue?: any) {
 		this.instance().runtime.log('info', 'Syncing storage...')
 		this._internalStore.tracking.forEach(async (object) => {

packages/tsconfig.shared.json

@@ -11,6 +11,7 @@
 		"noImplicitAny": false,
 		"noImplicitThis": true,
 		"skipLibCheck": true,
-		"esModuleInterop": true
+		"esModuleInterop": true,
+		"stripInternal": true
 	}
 }

tests/api.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, afterEach, describe, test, expect } from 'vitest'
 import { api, PlexusApi } from '@plexusjs/api'
+// only imported here to make sure it works in testing environment (node), not needed by user
 import 'isomorphic-fetch'
 
 // if(globalThis.fetch === undefined) globalThis.fetch = fetch as any as (input: RequestInfo, init?: RequestInit) => Promise<Response>;

tests/basic.test.ts

@@ -2,14 +2,20 @@ import { describe, test } from 'vitest'
 import {
 	DEFAULT_DECAY_RATE,
 	arrayState,
+	objectState,
+	stringState,
 	decayingUsers,
 	myCollection,
 	myCollectionUndefined,
-	objectState,
-	stringState,
 } from './test-utils'
 import { instance, state } from '@plexusjs/core'
 
+beforeEach(() => {
+	stringState.reset()
+	objectState.reset()
+	arrayState.reset()
+})
+
 describe('Collections Core Functionality', () => {
 	test('Can create collection', () => {
 		expect(myCollection.value.length).toBe(0)
@@ -68,19 +74,20 @@ describe('State Core Functionality', () => {
 
 	test('Checking state().set()', () => {
 		// check .set(value: object)
-		objectState.set({ a: { b: false } })
+		objectState.set({ a: { a2: false } })
 		// check if the object is actually merged and children props do get overwritten
-		expect(objectState.value.a?.b).toBe(false)
+		expect(objectState.value.a?.a2).toBe(false)
 	})
 
 	test('Checking state().patch()', () => {
+		objectState.set({ a: { a1: true, a2: true }, b: true })
 		// can the object deep merge?
-		objectState.patch({ a: { b: false } })
-		expect(objectState.value.a?.a).toBe(true)
+		objectState.patch({ a: { a2: false } })
+		expect(objectState.value.a?.a1).toBe(true)
 		// check that other value is still there
 		expect(objectState.value.b).toBe(true)
 		// changed intended value
-		expect(objectState.value.a?.b).toBe(false)
+		expect(objectState.value.a?.a2).toBe(false)
 
 		// console.log(arrayState.value)
 		// check array deep merge

tests/computed.test.ts

@@ -50,7 +50,11 @@ const core = {
 	}, [collections.books.getGroup('all')]),
 
 	numOfReadingReactiveToAll: computed(() => {
-		console.log('numOfReadingReactiveToAll compute...')
+		console.log(
+			'numOfReadingReactiveToAll compute...',
+			collections.books.getGroup('READING').value.length,
+			collections.books.getGroup('all').value.length
+		)
 		return collections.books.getGroup('READING').value.length
 	}, [collections.books.getGroup('all')]),
 }
@@ -129,9 +133,14 @@ describe('Testing Computed State Function', () => {
 	})
 	test('Computed can watch a default collection group', () => {
 		instance({ logLevel: 'debug' })
+		// start watching the reading group
 		collections.books.getGroup('READING')?.watch((v) => {
 			console.log('READING changed to: ', v)
 		})
+		collections.books.getGroup('all')?.watch((v) => {
+			console.log('ALL changed to: ', v)
+		})
+		// start watching the computed state that is watching the reading group
 		core.numOfReadingReactiveToAll.watch((v) => {
 			console.log('numOfReadingReactiveToAll.value changed to: ', v)
 		})
@@ -152,7 +161,8 @@ describe('Testing Computed State Function', () => {
 			core.numOfReadingReactiveToAll.value,
 			core.collections.books.size,
 			core.collections.books.getGroup('READING')?.size,
-			core.collections.books.getGroup('all')?.size
+			core.collections.books.getGroup('all')?.size,
+			core.collections.books.getGroup('all').value
 		)
 
 		expect(core.numOfReadingReactiveToAll.value).toBe(0)