@iebh/tera-fy 2.0.21 → 2.2.0

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

@@ -4,6 +4,7 @@ import {
 	random,
 	sample,
 	throttle,
+	isEqual
 } from 'lodash-es';
 import {
 	doc as FirestoreDocRef,
@@ -11,10 +12,32 @@ import {
 	onSnapshot as FirestoreOnSnapshot,
 	setDoc as FirestoreSetDoc,
 	updateDoc as FirestoreUpdateDoc,
+	DocumentReference,
+	Firestore,
+	Unsubscribe,
 } from 'firebase/firestore';
+// @ts-ignore
 import marshal from '@momsfriendlydevco/marshal';
 import {nanoid} from 'nanoid';
 import PromiseRetry from 'p-retry';
+import {FirebaseApp} from 'firebase/app';
+import { BoundSupabaseyFunction } from '@iebh/supabasey';
+
+
+interface ReactiveWrapper<T = any> {
+	doc: T;
+	setState: (newState: T) => void;
+	getState: () => T;
+	watch: (cb: (newState: T) => void) => void;
+}
+
+interface PathSplitResult {
+	fsCollection: string;
+	fsId: string;
+	entity: string;
+	id: string;
+	relation?: string;
+}
 
 
 /**
@@ -28,9 +51,9 @@ export default class Syncro {
 	/**
 	* Firebase instance in use
 	*
-	* @type {Firebase}
+	* @type {FirebaseApp}
 	*/
-	static firebase;
+	static firebase: FirebaseApp;
 
 
 	/**
@@ -38,15 +61,15 @@ export default class Syncro {
 	*
 	* @type {Firestore}
 	*/
-	static firestore;
+	static firestore: Firestore;
 
 
 	/**
-	* Supabase instance in use
+	* Supabasey instance in use
 	*
-	* @type {SupabaseClient}
+	* @type {Supabasey}
 	*/
-	static supabase;
+	static supabasey: BoundSupabaseyFunction;
 
 
 	/**
@@ -55,16 +78,16 @@ export default class Syncro {
 	*
 	* @type {String}
 	*/
-	static session;
+	static session: string | undefined;
 
 
 	/**
 	* OPTIONAL SyncroEntiries from './entiries.js' if its required
 	* This only gets populated if `config.forceLocalInit` is truthy and we've mounted at least one Syncro
 	*
-	* @type {Object}
+	* @type {Record<string, any>}
 	*/
-	static SyncroEntities;
+	static SyncroEntities: Record<string, any>;
 
 
 	/**
@@ -72,24 +95,24 @@ export default class Syncro {
 	*
 	* @type {String}
 	*/
-	path;
+	path: string;
 
 
 	/**
 	* The Firestore docHandle when calling various Firestore functions
 	*
-	* @type {FirestoreRef}
+	* @type {DocumentReference | undefined}
 	*/
-	docRef;
+	docRef: DocumentReference | undefined;
 
 
 	/**
 	* The reactive object managed by this Syncro instance
 	* The nature of this varies by framework and what `getReactive()` provides
 	*
-	* @type {*}
+	* @type {any}
 	*/
-	value;
+	value: any;
 
 
 	/**
@@ -109,9 +132,9 @@ export default class Syncro {
 	* @property {Object} context Additional named parameters to pass to callbacks like initState
 	*/
 	config = {
-		heartbeatInterval: 50_000, //~= 50s
-		syncroRegistryUrl: 'https://tera-tools.com/api/sync',
-		context: {},
+		heartbeatInterval: 50_000 as number, //~= 50s
+		syncroRegistryUrl: 'https://tera-tools.com/api/sync' as string,
+		context: {} as Record<string, any>,
 	};
 
 
@@ -133,7 +156,7 @@ export default class Syncro {
 	*
 	* @param {*...} [msg] The message to output
 	*/
-	debug(...msg) {} // eslint-disable-line no-unused-vars
+	debug(...msg: any[]) {} // eslint-disable-line no-unused-vars
 
 
 	/**
@@ -143,7 +166,7 @@ export default class Syncro {
 	*
 	* @param {*...} [msg] The message to output
 	*/
-	debugError(...msg) {
+	debugError(...msg: any[]) {
 		console.log(`[Syncro ${this.path}]`, ...msg);
 	}
 
@@ -154,7 +177,7 @@ export default class Syncro {
 	* @param {String} path Mount path for the Syncro. Should be in the form `${ENTITY}::${ID}(::${RELATION})?`
 	* @param {Object} [options] Additional instance setters (mutates instance directly), note that the `config` subkey is merged with the existing config rather than assigned
 	*/
-	constructor(path, options) {
+	constructor(path: string, options?: any) {
 		this.path = path;
 		Object.assign(this, {
 			...options,
@@ -175,7 +198,7 @@ export default class Syncro {
 	*
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	destroy() {
+	destroy(): Promise<any[]> {
 		this.debug('Destroy!');
 		return Promise.all(this._destroyActions
 			.map(fn => fn())
@@ -188,9 +211,9 @@ export default class Syncro {
 	* Actions to preform when we are destroying this instance
 	* This is an array of function callbacks to execute in parallel when `destroy()` is called
 	*
-	* @type {Array<Function>}
+	* @type {Array<() => void>}
 	*/
-	_destroyActions = [];
+	_destroyActions: Array<() => void> = [];
 
 
 	/**
@@ -199,18 +222,18 @@ export default class Syncro {
 	*
 	* @param {Object} value Initial value of the reactive
 	*
-	* @returns {Object} A reactive object prototype
+	* @returns {ReactiveWrapper} A reactive object prototype
 	* @property {Object} doc The reactive object
 	* @property {Function} setState Function used to overwrite the default state, called as `(newState:Object)`
 	* @property {Function} getState Function used to fetch the current snapshot state, called as `()`
 	* @property {Function} watch Function used to set up state watchers, should call its callback when a change is detected, called as `(cb:Function)`
 	*/
-	getReactive(value) {
+	getReactive(value: any): ReactiveWrapper {
 		console.warn('Syncro.getReactive has not been subclassed, assuming a POJO response');
-		let doc = {...value};
+		let doc: Record<string, any> = {...value};
 		return {
 			doc,
-			setState(state) {
+			setState(state: any) {
 				// Shallow copy all sub keys into existing object (keeping the object pointer)
 				Object.entries(state || {})
 					.forEach(([k, v]) => doc[k] = v)
@@ -218,7 +241,7 @@ export default class Syncro {
 			getState() {
 				return cloneDeep(doc);
 			},
-			watch(cb) { // eslint-disable-line no-unused-vars
+			watch(cb: (newState: any) => void) { // eslint-disable-line no-unused-vars
 				// Stub
 			},
 		};
@@ -237,14 +260,9 @@ export default class Syncro {
 	* @param {Object} [options] Additional options to mutate behaviour
 	* @param {Boolean} [options.allowAsterisk=false] Whether to allow the meta asterisk character when recognising paths, this is used by the SyncroKeyed class
 	*
-	* @returns {Object} An object composed of the session path components
-	* @property {String} fbEntity The top level Firebase collection to store within
-	* @property {String} fsId The top level Firebase ID of the collection to store as, this is either just a copy of the ID or a combination of id + relation
-	* @property {String} entity A valid entity name (in plural form e.g. 'projects')
-	* @property {String} id A valid UUID ID
-	* @property {String} [relation] A string representing a sub-relationship. Usually a short string alias
+	* @returns {PathSplitResult} An object composed of the session path components
 	*/
-	static pathSplit(path, options) {
+	static pathSplit(path: string, options?: any): PathSplitResult {
 		let settings = {
 			allowAsterisk: false,
 			...options,
@@ -264,10 +282,10 @@ export default class Syncro {
 			+ '$'
 		);
 
-		let extracted = { ...pathMatcher.exec(path)?.groups };
+		let extracted = { ...pathMatcher.exec(path)?.groups } as { entity?: string, id?: string, relation?: string };
 
-		if (!extracted) throw new Error(`Invalid session path syntax "${path}"`);
-		if (Syncro.SyncroEntities && !(extracted.entity in SyncroEntities)) throw new Error(`Unsupported entity "${path}" -> Entity="${extracted.entity}"`);
+		if (!extracted || !extracted.entity || !extracted.id) throw new Error(`Invalid session path syntax "${path}"`);
+		if (Syncro.SyncroEntities && !(extracted.entity in Syncro.SyncroEntities)) throw new Error(`Unsupported entity "${path}" -> Entity="${extracted.entity}"`);
 
 		return {
 			entity: extracted.entity,
@@ -291,7 +309,7 @@ export default class Syncro {
 	* @param {Object} snapshot The current state to convert
 	* @returns {Object} A Firebase compatible object
 	*/
-	static toFirestore(snapshot = {}) {
+	static toFirestore(snapshot: any = {}): any {
 		return marshal.serialize(snapshot, {
 			circular: false,
 			clone: true, // Clone away from the original Vue Reactive so we dont mangle it while traversing
@@ -311,7 +329,7 @@ export default class Syncro {
 	* @param {Object} snapshot The raw Firebase state to convert
 	* @returns {Object} A JavaScript POJO representing the converted state
 	*/
-	static fromFirestore(snapshot = {}) {
+	static fromFirestore(snapshot: any = {}): any {
 		return marshal.deserialize(snapshot, {
 			circular: false,
 			clone: true, // Clone away from original so we don't trigger a loop within Firebase
@@ -333,8 +351,8 @@ export default class Syncro {
 	* @param {Object} data The raw value to convert
 	* @returns {Object} A Firestore compatible, typed data structure
 	*/
-	static toFirestoreFields(data) {
-		const result = {};
+	static toFirestoreFields(data: any): Record<string, any> {
+		const result: Record<string, any> = {};
 
 		for (const [key, value] of Object.entries(data)) {
 			const type = typeof value;
@@ -348,9 +366,11 @@ export default class Syncro {
 			} else if (value === null) {
 				result[key] = { nullValue: null };
 			} else if (Array.isArray(value)) {
-				result[key] = { arrayValue: { values:
-					value.map(item => Syncro.toFirestoreFields({item}).item)
-				}};
+				// Need to handle the inner item structure correctly
+				result[key] = { arrayValue: { values: value.map(item => {
+					const field = Syncro.toFirestoreFields({ item });
+					return field.item; // Extract the typed value from the temporary {item: ...} structure
+				}) } };
 			} else if (type === 'object') {
 				result[key] = { mapValue: { fields: Syncro.toFirestoreFields(value) } };
 			}
@@ -369,26 +389,25 @@ export default class Syncro {
 	* @param {Object} fields The raw Snapshot to convert
 	* @returns {Object} A JavaScript POJO representing the converted state
 	*/
-	static fromFirestoreFields(fields = {}) {
-		let result = {};
+	static fromFirestoreFields(fields: any = {}): any {
+		let result: Record<string, any> = {};
 		for (let key in fields) {
 			let value = fields[key];
 			let isDocumentType = [
 				'stringValue', 'booleanValue', 'doubleValue',
-				'integerValue', 'timestampValue', 'mapValue', 'arrayValue', 'nullValue',
-			].find(t => t === key);
+				'integerValue', 'timestampValue', 'mapValue', 'arrayValue', 'nullValue', // Added nullValue
+			].find(t => t === Object.keys(value)[0]); // Check the first key of the value object
 
 			if (isDocumentType) {
-				let item = ['stringValue', 'booleanValue', 'doubleValue', 'integerValue', 'timestampValue']
-					.find(t => t === key)
-
-				if (item) {
-					return value;
-				} else if ('mapValue' == key) {
-					return Syncro.fromFirestoreFields(value.fields || {});
-				} else if ('arrayValue' == key) {
-					let list = value.values;
-					return !!list ? list.map(l => Syncro.fromFirestoreFields(l)) : [];
+				if (isDocumentType === 'mapValue') {
+					result[key] = Syncro.fromFirestoreFields(value.mapValue.fields || {});
+				} else if (isDocumentType === 'arrayValue') {
+					let list = value.arrayValue.values;
+					result[key] = !!list ? list.map((l: any) => Syncro.fromFirestoreFields(l)) : [];
+				} else if (isDocumentType === 'nullValue') {
+					result[key] = null;
+				} else {
+					result[key] = value[isDocumentType];
 				}
 			} else {
 				// This case might not be standard Firestore field structure, but handle recursively
@@ -406,14 +425,14 @@ export default class Syncro {
 	*
 	* @returns {Promise<Object|Null>} An eventual snapshot of the given path, if the entity doesn't exist null is returned
 	*/
-	static getSnapshot(path) {
+	static getSnapshot(path: string): Promise<any | null> {
 		let {fsCollection, fsId} = Syncro.pathSplit(path);
 
 		return Promise.resolve()
 			.then(async ()=> FirestoreGetDoc( // Set up binding and wait for it to come ready
 				FirestoreDocRef(Syncro.firestore, fsCollection, fsId)
 			))
-			.then(doc => doc
+			.then(doc => doc.exists() // Use exists() method
 				? Syncro.fromFirestore(doc.data())
 				: null
 			)
@@ -431,20 +450,23 @@ export default class Syncro {
 	*
 	* @returns {Promise<*>} The state object after it has been applied
 	*/
-	static setSnapshot(path, state, options) {
+	static setSnapshot(path: string, state: any, options?: { method?: 'merge' | 'set' }): Promise<any> {
 		let settings = {
 			method: 'merge',
 			...options,
 		};
 		let {fsCollection, fsId} = Syncro.pathSplit(path);
+		const docRef = FirestoreDocRef(Syncro.firestore, fsCollection, fsId);
+		const firestoreData = Syncro.toFirestore(state);
 
 		return Promise.resolve()
-			.then(()=> // Set up binding and wait for it to come ready
-				(settings.method == 'merge' ? 'FirestoreUpdateDoc' : 'FirestoreSetDoc')(
-					FirestoreDocRef(Syncro.firestore, fsCollection, fsId),
-					Syncro.toFirestore(state),
-				)
-			)
+			.then(()=> {
+				if (settings.method === 'merge') {
+					return FirestoreUpdateDoc(docRef, firestoreData);
+				} else { // method === 'set'
+					return FirestoreSetDoc(docRef, firestoreData); // Default set overwrites
+				}
+			})
 			.then(()=> state)
 	}
 
@@ -457,7 +479,7 @@ export default class Syncro {
 	* @param {Number} [options.retries=3] Number of times to retry if a mounted Syncro fails its sanity checks
 	* @returns {Promise<Syncro>} A promise which resolves as this syncro instance when completed
 	*/
-	mount(options) {
+	mount(options?: any): Promise<Syncro> {
 		let settings = {
 			initialState: null,
 			retries: 5,
@@ -466,68 +488,68 @@ export default class Syncro {
 		};
 
 		let {fsCollection, fsId, entity} = Syncro.pathSplit(this.path);
-		let reactive; // Eventual response from reactive() with the intitial value
-		let doc; // Eventual Firebase document
+		let reactive: ReactiveWrapper; // Eventual response from reactive() with the intitial value
+		let doc: any; // Eventual Firebase document
 
 		return PromiseRetry(
-			()=> Promise.resolve()
-				.then(()=> this.setHeartbeat(false)) // Disable any existing heartbeat - this only really applies if we're changing path for some reason
-				.then(async ()=> { // Set up binding and wait for it to come ready
-					this.docRef = FirestoreDocRef(Syncro.firestore, fsCollection, fsId);
-
-					// Initalize state
-					let initialState = await this.getFirestoreState();
-
-					// Construct a reactive component
-					reactive = this.getReactive(initialState);
-					if (!reactive.doc || !reactive.setState || !reactive.getState || !reactive.watch) throw new Error('Syncro.getReactive() requires a returned `doc`, `setState()`, `getState()` + `watch()`');
-					this.value = doc = reactive.doc;
-
-					this.debug('Initial state', {doc});
-
-					// Subscribe to remote updates
-					this._destroyActions.push( // Add the unsubscribe handle to the list of destroyAction promises we call on `destroy()`
-						FirestoreOnSnapshot(this.docRef, snapshot => {
-							let snapshotData = Syncro.fromFirestore(snapshot.data());
-							this.debug('Incoming snapshot', {snapshotData});
-							reactive.setState(snapshotData);
-						})
-					);
-				})
-				.then(()=> { // Optionally create the doc if it has no content
-					if (!isEmpty(doc)) { // Doc already has content - skip
-						return;
-					} else if (settings.initialState) { // Provided an intiailState - use that instead of the entities own method
-						this.debug('Populate initial Syncro state (from provided initialState)');
-						return this.setFirestoreState(settings.initialState, {method: 'set'});
-					} else {
-						this.debug(`Populate initial Syncro state (from "${entity}" Syncro worker)`);
-
-						return fetch(`${this.config.syncroRegistryUrl}/${this.path}`)
-							.then(response => response.ok || Promise.reject(`Failed to check Syncro "${fsCollection}::${fsId}" status - ${response.statusText}`))
+			async (): Promise<Syncro> => { // Added async here for await
+				await this.setHeartbeat(false); // Disable any existing heartbeat - this only really applies if we're changing path for some reason
+
+				// Set up binding and wait for it to come ready
+				this.docRef = FirestoreDocRef(Syncro.firestore, fsCollection, fsId);
+
+				// Initalize state
+				let initialState = await this.getFirestoreState();
+
+				// Construct a reactive component
+				reactive = this.getReactive(initialState);
+				if (!reactive.doc || !reactive.setState || !reactive.getState || !reactive.watch) throw new Error('Syncro.getReactive() requires a returned `doc`, `setState()`, `getState()` + `watch()`');
+				this.value = doc = reactive.doc;
+
+				this.debug('Initial state', {doc});
+
+				// Subscribe to remote updates
+				const unsubscribe: Unsubscribe = FirestoreOnSnapshot(this.docRef, snapshot => {
+					let snapshotData = Syncro.fromFirestore(snapshot.data());
+					this.debug('Incoming snapshot', {snapshotData});
+					reactive.setState(snapshotData);
+				});
+				this._destroyActions.push(unsubscribe); // Add the unsubscribe handle to the list of destroyAction promises we call on `destroy()`
+
+				// Optionally create the doc if it has no content
+				if (!isEmpty(doc)) { // Doc already has content - skip
+					// Do nothing
+				} else if (settings.initialState) { // Provided an intiailState - use that instead of the entities own method
+					this.debug('Populate initial Syncro state (from provided initialState)');
+					await this.setFirestoreState(settings.initialState, {method: 'set'});
+				} else {
+					this.debug(`Populate initial Syncro state (from "${entity}" Syncro worker)`);
+					const response = await fetch(`${this.config.syncroRegistryUrl}/${this.path}`);
+					if (!response.ok) {
+						throw new Error(`Failed to check Syncro "${fsCollection}::${fsId}" status - ${response.statusText}`);
 					}
-				})
-				.then(()=> { // Setup local state watcher
-					reactive.watch(throttle(newState => {
-						this.debug('Local change', {newState});
-						this.markDirty();
-						this.setFirestoreState(newState, {method: 'merge'});
-					}, this.throttle));
-				})
-				.then(()=> this.setHeartbeat(true, {
+					// Assuming the fetch populates the syncro state server-side, no local state set needed here
+				}
+
+				// Setup local state watcher
+				reactive.watch(throttle((newState: any) => {
+					this.debug('Local change', {newState});
+					this.markDirty();
+					this.setFirestoreState(newState, {method: 'merge'});
+				}, this.throttle));
+
+				await this.setHeartbeat(true, {
 					immediate: true,
-				}))
-				.then(()=> this)
-				.catch(async (e) => {
-					await this.destroy();
-					throw e;
-				}),
+				});
+
+				return this;
+			},
 			{ // PromiseRetry / p-retry options
 				retries: settings.retries,
 				minTimeout: settings.retryMinTime,
 				randomize: true,
 				factor: 3,
-				onFailedAttempt: async (e) => {
+				onFailedAttempt: async (e: any) => {
 					this.debugError(`[Attempt ${e.attemptNumber}/${e.attemptNumber + e.retriesLeft - 1}] to mount syncro`, e);
 					await this.destroy(); // Ensure cleanup on failed attempt before retry
 				},
@@ -535,24 +557,28 @@ export default class Syncro {
 		);
 	}
 
-
 	/**
 	* Merge a single or multiple values into a Syncro data object
+	* NOTE: Default behaviour is to flush (if any changes apply), use direct object mutation or disable with `flush:false` to disable
 	*
 	* @param {String|Object} key Either the single named key to set OR the object to merge
 	* @param {*} [value] The value to set if `key` is a string
 	*
 	* @param {Object} [options] Additional options to mutate behaviour
 	* @param {Boolean} [options.delta=true] Only merge keys that differ, skipping flush if no changes are made
-	* @param {Boolean} [options.flush=false] Send a flush signal that Firebase should sync to Supabase on changes
+	* @param {Boolean} [options.flush=true] Send a flush signal that Firebase should sync to Supabase on changes
 	* @param {Boolean} [options.forceFlush=false] Flush even if no changes were made
 	* @param {Boolean} [options.flushDestroy=false] Destroy the Syncro after flushing
 	*
 	* @returns {Promise<Syncro>} A promise which resolves with this Syncro instance on completion
 	*/
-	async set(key, value, options) {
+	async set(
+		key: string | object,
+		value: any,
+		options: { delta?: boolean, flush?: boolean, forceFlush?: boolean, flushDestroy?: boolean }
+	) {
 		// Argument mangling - [key, value, settings] -> changes{}, settings {{{
-		let changes;
+		let changes: any;
 		if (typeof key == 'string') { // Called as (key:String, value:*, options?:Object)
 			changes[key] = value;
 		} else if (typeof key == 'object') { // Called as (changes:Object, options?:Object)
@@ -564,7 +590,7 @@ export default class Syncro {
 
 		let settings = {
 			delta: true,
-			flush: false,
+			flush: true,
 			forceFlush: false,
 			flushDestroy: false,
 			...options,
@@ -595,7 +621,6 @@ export default class Syncro {
 		return this;
 	}
 
-
 	/**
 	* Schedule Syncro heartbeats
 	* This populates the `sync` presence meta-information
@@ -605,7 +630,7 @@ export default class Syncro {
 	* @param {Object} [options] Additional options to mutate behaviour
 	* @param {Boolean} [options.immediate=false] Fire a heartbeat as soon as this function is called, this is only really useful on mount
 	*/
-	setHeartbeat(enable = true, options) {
+	setHeartbeat(enable: boolean = true, options?: any): Promise<void> | void { // Return type adjusted
 		let settings = {
 			immediate: true,
 			...options,
@@ -615,15 +640,17 @@ export default class Syncro {
 		clearTimeout(this._heartbeatTimer);
 
 		if (enable) {
-			this._heartbeatTimer = setTimeout(async ()=> {
+			const heartbeatAction = async () => {
 				// Perform the heartbeat
 				await this.heartbeat();
 
 				// If we're enabled - schedule the next heartbeat timer
-				if (enable) this.setHeartbeat(true);
-			}, this.config.heartbeatInterval);
+				if (enable) this.setHeartbeat(true); // Reschedule
+			};
 
-			if (settings.immediate) this.heartbeat();
+			this._heartbeatTimer = setTimeout(heartbeatAction, this.config.heartbeatInterval);
+
+			if (settings.immediate) return this.heartbeat(); // Return the promise from immediate heartbeat
 		}
 	}
 
@@ -634,24 +661,29 @@ export default class Syncro {
 	*
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	async heartbeat() {
+	async heartbeat(): Promise<void> {
 		this.debug('heartbeat!');
 
-		await fetch(`${this.config.syncroRegistryUrl}/${this.path}/heartbeat`, {
-			method: 'post',
-			headers: {
-				'Content-Type': 'application/json'
-			},
-			body: JSON.stringify({
-				session: Syncro.session,
-				...(this.isDirty && {dirty: true}),
-			}),
-		})
-			.then(response => response.ok
-				? null
-				: console.warn(this.path, `Heartbeat failed - ${response.statusText}`, {response})
-			)
-			.then(()=> this.isDirty = false) // Reset the dirty flag if it is set
+		try {
+			const response = await fetch(`${this.config.syncroRegistryUrl}/${this.path}/heartbeat`, {
+				method: 'post',
+				headers: {
+					'Content-Type': 'application/json'
+				},
+				body: JSON.stringify({
+					session: Syncro.session,
+					...(this.isDirty && {dirty: true}),
+				}),
+			});
+
+			if (!response.ok) {
+				console.warn(this.path, `Heartbeat failed - ${response.statusText}`, {response});
+			}
+			this.isDirty = false; // Reset the dirty flag if it is set
+		} catch (error) {
+			console.warn(this.path, 'Heartbeat fetch error', error);
+			// Decide if isDirty should be reset on network error
+		}
 	}
 
 
@@ -664,17 +696,20 @@ export default class Syncro {
 	*
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	setFirestoreState(state, options) {
+	setFirestoreState(state: any, options?: { method?: 'merge' | 'set' }): Promise<void> {
 		let settings = {
 			method: 'merge',
 			...options,
 		};
 		if (!this.docRef) throw new Error('mount() must be called before setting Firestore state');
 
-		return (settings.method == 'set' ? FirestoreSetDoc : FirestoreUpdateDoc)(
-			this.docRef,
-			Syncro.toFirestore(state),
-		)
+		const firestoreData = Syncro.toFirestore(state);
+
+		if (settings.method === 'merge') {
+			return FirestoreUpdateDoc(this.docRef, firestoreData);
+		} else { // method === 'set'
+			return FirestoreSetDoc(this.docRef, firestoreData);
+		}
 	}
 
 
@@ -684,7 +719,7 @@ export default class Syncro {
 	*
 	* @returns {Promise<Object>} A promise which resolves to the Firestore state
 	*/
-	getFirestoreState() {
+	getFirestoreState(): Promise<any> {
 		if (!this.docRef) throw new Error('mount() must be called before getting Firestore state');
 
 		return FirestoreGetDoc(this.docRef)
@@ -698,7 +733,7 @@ export default class Syncro {
 	* @see isDirty
 	* @returns {Syncro} This chainable Syncro instance
 	*/
-	markDirty() {
+	markDirty(): this {
 		this.isDirty = true;
 		return this;
 	}
@@ -713,7 +748,7 @@ export default class Syncro {
 	*
 	* @returns {Promise} A promise which resolves when the operation has completed
 	*/
-	flush(options) {
+	flush(options?: any): Promise<void | null> {
 		let settings = {
 			destroy: false,
 			...options,
@@ -723,16 +758,16 @@ export default class Syncro {
 			.then(response => response.ok
 				? null
 				: Promise.reject(response.statusText || 'An error occured')
-			)
+			);
 	}
 
 
 	/**
 	* Timer handle for heartbeats
 	*
-	* @type {Handle}
+	* @type {any}
 	*/
-	_heartbeatTimer;
+	_heartbeatTimer: any; // Using any for simplicity with NodeJS.Timeout / number
 }
 
 
@@ -744,7 +779,7 @@ export default class Syncro {
 *
 * @returns {*} The current branch conotents
 */
-export function randomBranch(depth = 0) {
+export function randomBranch(depth: number = 0): any {
 	let dice = // Roll a dice to pick the content
 		depth == 0 ? 10 // first roll is always '10'
 		: random(0, 11 - depth, false); // Subsequent rolls bias downwards based on depth (to avoid recursion)
@@ -754,12 +789,12 @@ export function randomBranch(depth = 0) {
 		: dice == 1 ? true
 		: dice == 2 ? random(1, 10_000)
 		: dice == 3 ? (new Date(random(1_000_000_000_000, 1_777_777_777_777))).toISOString()
-		: dice == 5 ? Array.from({length: random(1, 10)}, ()=> random(1, 10))
+		: dice == 5 ? Array.from({length: random(1, 10)}, (): number => random(1, 10)) // Added return type hint
 		: dice == 6 ? null
-		: dice < 8 ? Array.from({length: random(1, 10)}, ()=> randomBranch(depth+1))
+		: dice < 8 ? Array.from({length: random(1, 10)}, (): any => randomBranch(depth+1)) // Added return type hint
 		: Object.fromEntries(
 			Array.from({length: random(1, 5)})
-				.map((v, k) => [
+				.map((v, k): [string, any] => [ // Added return type hint
 					sample(['foo', 'bar', 'baz', 'quz', 'flarp', 'corge', 'grault', 'garply', 'waldo', 'fred', 'plugh', 'thud'])
 					+ `_${k}`,
 					randomBranch(depth+1),
@@ -776,14 +811,14 @@ export function randomBranch(depth = 0) {
 const marshalFlattenArrays = {
 	id: `~array`,
 	recursive: true,
-	test: v => Array.isArray(v),
-	serialize: v => ({_: '~array', ...v}),
-	deserialize: v => {
-		let arr = Array.from({length: Object.keys(v).length - 1});
+	test: (v: any): boolean => Array.isArray(v),
+	serialize: (v: any): any => ({_: '~array', ...v}),
+	deserialize: (v: any): any[] => {
+		let arr: any[] = Array.from({length: Object.keys(v).length - 1});
 
 		Object.entries(v)
 			.filter(([k]) => k !== '_')
-			.forEach(([k, w]) => arr[+k] = w);
+			.forEach(([k, val]) => arr[+k] = val); // Changed v to val to avoid shadowing
 
 		return arr;
 	},