@iebh/tera-fy 2.3.11 → 2.3.12

package/lib/syncro/{keyed.ts → keyed.js}

@@ -3,19 +3,6 @@ import {doc as FirestoreDocRef, getDoc as FirestoreGetDoc} from 'firebase/firest
 import Syncro from './syncro.js';
 import SyncroEntities from './entities.js';
 
-// Define a basic structure for what pathSplit should return
-interface PathSplitResult {
-	entity: string;
-	id: string;
-	relation?: string; // Making relation optional
-	fsCollection: string;
-	fsId: string;
-}
-
-// Define a structure for options passed to flush
-interface FlushOptions {
-	destroy?: boolean;
-}
 
 /**
 * @class SyncroKeyed
@@ -41,7 +28,7 @@ export default class SyncroKeyed extends Syncro {
 	* Various storage about keyed path
 	*/
 	keyedPath = {
-		getKey(path: string, index: number): string {
+		getKey(path, index) {
 			return path + '_' + index;
 		},
 	};
@@ -52,7 +39,7 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @type {Array<Syncro>}
 	*/
-	members: Syncro[] = [];
+	members = [];
 
 
 	/**
@@ -61,13 +48,13 @@ export default class SyncroKeyed extends Syncro {
 	* @param {String} path Mount path for the Syncro. Should be in the form `${ENTITY}::${ID}(::${RELATION})?_*` (must contain a '*' operator)
 	* @param {Object} [options] Additional instance setters (mutates instance directly)
 	*/
-	constructor(path: string, options?: Record<string, any>) {
+	constructor(path, options) {
 		super(path, options);
 
 		if (!/\*/.test(path)) throw new Error('SyncroKeyed paths must contain at least one asterisk as an object pagination indicator');
 
-		const {prefix, suffix} = /^(?<prefix>.+)\*(?<suffix>.*)$/.exec(path)!.groups!;
-		this.keyedPath.getKey = (path: string, index: number): string => `${prefix}${index}${suffix}`;
+		const {prefix, suffix} = /^(?<prefix>.+)\*(?<suffix>.*)$/.exec(path).groups;
+		this.keyedPath.getKey = (path, index) => `${prefix}${index}${suffix}`;
 	}
 
 
@@ -76,7 +63,7 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	async destroy(): Promise<never[]> { // Match base class signature
+	async destroy() {
 		this.debug('Destroy!');
 		await Promise.all(
 			this.members.map(member =>
@@ -85,7 +72,7 @@ export default class SyncroKeyed extends Syncro {
 		);
 
 		this.members = [];
-		return [] as never[]; // Return empty array cast to never[] to satisfy signature
+		return [];
 	}
 
 
@@ -95,15 +82,14 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @returns {Promise<Syncro>} A promise which resolves as this SyncroKeyed instance when completed
 	*/
-	mount(): Promise<Syncro> {
-		// Cast the result to the expected interface
-		const {entity, id, relation, fsCollection, fsId} = Syncro.pathSplit(this.path, {allowAsterisk: true}) as PathSplitResult;
+	mount() {
+		const {entity, id, relation, fsCollection, fsId} = Syncro.pathSplit(this.path, {allowAsterisk: true});
 
 		return Promise.resolve()
-			.then(()=> new Promise<void>(resolve => { // Mount all members by looking for similar keys
+			.then(()=> new Promise(resolve => { // Mount all members by looking for similar keys
 				this.members = []; // Reset member list
 
-				const seekMember = async (index: number) => {
+				const seekMember = async index => {
 					const memberId = fsId.replace('*', ''+index);
 					this.debug('Seek keyedMember', fsCollection, '#', memberId);
 
@@ -146,8 +132,6 @@ export default class SyncroKeyed extends Syncro {
 			})
 			.then(()=> { // Create the reactive
 				const reactive = this.getReactive(this.proxy());
-				// Assuming this.value should hold the reactive proxy
-				// If this.value is inherited and has a specific type, this might need adjustment
 				this.value = reactive.doc;
 			})
 			.then(()=> this)
@@ -159,40 +143,39 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @returns {Proxy} A proxy of all combined members
 	*/
-	proxy(): Record<string | symbol, any> { // Return type can be more specific if needed
+	proxy() {
 		return new Proxy(this, {
 			// Return the full list of keys
-			ownKeys(target: SyncroKeyed): ArrayLike<string | symbol> {
+			ownKeys(target) {
 				return target.members.flatMap(m => Object.keys(m.value || {}));
 			},
 
 			// Return if we have a lookup key
-			has(target: SyncroKeyed, prop: string | symbol): boolean {
+			has(target, prop) {
 				// Ensure m.value exists before checking property
 				return target.members.some(m => m.value && prop in m.value);
 			},
 
 			// Scope through members until we get a hit on the key
-			get(target: SyncroKeyed, prop: string | symbol): any {
+			get(target, prop) {
 				const targetMember = target.members.find(m => m.value && prop in m.value);
 				// Access value via targetMember.value if found
 				return targetMember ? targetMember.value[prop] : undefined;
 			},
 
 			// Set the member key if one already exists, otherwise overflow onto the next member
-			set(target: SyncroKeyed, prop: string | symbol, value: any): boolean {
+			set(target, prop, value) {
 				const targetMember = target.members.find(m => m.value && prop in m.value);
 				if (targetMember && targetMember.value) {
 					targetMember.value[prop] = value;
 				} else {
-					// Assuming keyedSet handles adding the value appropriately
-					target.keyedSet(prop as string, value); // Cast prop to string if keyedSet expects string
+					target.keyedSet(prop, value);
 				}
 				return true; // Proxy set must return boolean
 			},
 
 			// Remove a key
-			deleteProperty(target: SyncroKeyed, prop: string | symbol): boolean {
+			deleteProperty(target, prop) {
 				const targetMember = target.members.find(m => m.value && prop in m.value);
 				if (targetMember && targetMember.value) {
 					delete targetMember.value[prop];
@@ -212,22 +195,21 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	async flush(options?: FlushOptions): Promise<void> { // Match base class signature
-		const settings: FlushOptions = {
+	async flush(options) {
+		const settings = {
 			destroy: false,
 			...options,
 		};
 
 		await Promise.all(
 			this.members.map(member =>
-				member.flush({ // Assuming member.flush returns Promise<void> now
+				member.flush({
 					destroy: settings.destroy,
 				})
 			)
 		);
 
 		if (settings.destroy) await this.destroy();
-		return; // Return void to match signature
 	}
 
 
@@ -240,7 +222,7 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @returns {Promise<*>} A promise which resolves when the operation has completed with the set value
 	*/
-	async keyedSet(key: string, value: any): Promise<any> {
+	async keyedSet(key, value) {
 		const candidateMember = this.members.find(m => m.value && Object.keys(m.value).length < this.keyedConfig.maxKeys);
 		if (candidateMember?.value) {
 			candidateMember.value[key] = value;
@@ -274,7 +256,7 @@ export default class SyncroKeyed extends Syncro {
 	*
 	* @param {Object} state The value to merge
 	*/
-	async keyedAssign(state: Record<string, any>): Promise<void> {
+	async keyedAssign(state) {
 		// Can we assume we have a blank state - this speeds up existing key checks significantly
 		// Ensure members[0] and its value exist
 		const isBlank = this.members.length === 1 && this.members[0]?.value && Object.keys(this.members[0].value).length === 0;
@@ -291,21 +273,19 @@ export default class SyncroKeyed extends Syncro {
 					if (!this.members[chunkIndex]) await this.keyedMembersExpand(chunkIndex);
 
 					// Ensure the member exists and has setFirestoreState method
-                    const member = this.members[chunkIndex];
-                    if (member && typeof (member as any).setFirestoreState === 'function') {
-					    // Populate its state - Cast to any temporarily if setFirestoreState is not public/recognized
-					    await (member as any).setFirestoreState(chunk, {method: 'set'});
-                    } else {
-                        console.warn(`Member at index ${chunkIndex} is missing or does not have setFirestoreState`);
-                    }
+					const member = this.members[chunkIndex];
+					if (member && typeof member.setFirestoreState === 'function') {
+						await member.setFirestoreState(chunk, {method: 'set'});
+					} else {
+						console.warn(`Member at index ${chunkIndex} is missing or does not have setFirestoreState`);
+					}
 				})
 			);
 
 		} else { // Non-blank - call keyedSet() on each key of state, merging slowly
-			// Replace Array.fromAsync with a standard loop
-            for (const [key, val] of Object.entries(state)) {
-                await this.keyedSet(key, val);
-            }
+			for (const [key, val] of Object.entries(state)) {
+				await this.keyedSet(key, val);
+			}
 		}
 	}
 
@@ -316,21 +296,19 @@ export default class SyncroKeyed extends Syncro {
 	* @param {Number} [index] The index to use when expanding, if omitted the next index offset is used
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	async keyedMembersExpand(index?: number): Promise<void> {
+	async keyedMembersExpand(index) {
 		index = index ?? this.members.length; // Use provided index or next available slot
 		if (this.members[index]) {
-            // If member already exists (e.g., during initial seek), just ensure it's mounted.
-            // If it was called intentionally with an existing index, maybe log a warning or skip.
-            this.debug(`keyedMembersExpand called for existing index ${index}, ensuring mounted.`);
-            if (!this.members[index].value) { // If it exists but isn't mounted somehow
-                 await this.members[index].mount({ initialState: {} });
-            }
-            return; // Exit if member already exists
-        }
+			// If member already exists (e.g., during initial seek), just ensure it's mounted.
+			this.debug(`keyedMembersExpand called for existing index ${index}, ensuring mounted.`);
+			if (!this.members[index].value) { // If it exists but isn't mounted somehow
+				await this.members[index].mount({initialState: {}});
+			}
+			return; // Exit if member already exists
+		}
 
 		const syncroPath = this.keyedPath.getKey(this.path, index);
-		// Pass empty options object {} or specify allowAsterisk: false if needed
-		const {fsCollection, fsId} = Syncro.pathSplit(syncroPath, {}) as PathSplitResult;
+		const {fsCollection, fsId} = Syncro.pathSplit(syncroPath, {});
 		this.debug('Expand SyncroKeyed size to index=', index);
 
 		// Create a new Syncro member, inheriteing some details from this parent item
@@ -345,11 +323,11 @@ export default class SyncroKeyed extends Syncro {
 		});
 
 		// Insert at the correct index if specified, otherwise push
-        if (index < this.members.length) {
-            this.members.splice(index, 0, syncro);
-        } else {
-		    this.members.push(syncro);
-        }
+		if (index < this.members.length) {
+			this.members.splice(index, 0, syncro);
+		} else {
+			this.members.push(syncro);
+		}
 	}
 
 }