@teardown/react-native 2.0.1 → 2.0.2

package/src/clients/force-update/force-update.client.ts

@@ -71,7 +71,11 @@ export type VersionStatusChangeEvents = {
 export type ForceUpdateClientOptions = {
 	/** Min ms between foreground checks (default: 30000) */
 	throttleMs?: number;
-	/** Min ms since last successful check before re-checking (default: 300000 = 5min) */
+	/** 
+	 * Min ms since last successful check before re-checking (default: 300000 = 5min)
+	 * Set this to 0 to disable cooldown and check immediately on every foreground transition.
+	 * Set to -1 disable checking entirely.
+	 */
 	checkCooldownMs?: number;
 };
 
@@ -84,11 +88,12 @@ export const VERSION_STATUS_STORAGE_KEY = "VERSION_STATUS";
 
 export class ForceUpdateClient {
 	private emitter = new EventEmitter<VersionStatusChangeEvents>();
-	private versionStatus: VersionStatus;
+	private versionStatus: VersionStatus = { type: "initializing" };
 	private unsubscribe: (() => void) | null = null;
 	private appStateSubscription: NativeEventSubscription | null = null;
 	private lastCheckTime: number | null = null;
 	private lastForegroundTime: number | null = null;
+	private initialized = false;
 
 	private readonly logger: Logger;
 	private readonly storage: SupportedStorage;
@@ -103,18 +108,55 @@ export class ForceUpdateClient {
 		this.logger = logging.createLogger({ name: "ForceUpdateClient" });
 		this.storage = storage.createStorage("version");
 		this.options = { ...DEFAULT_OPTIONS, ...options };
+		// Don't initialize here - defer to initialize()
+	}
+
+	initialize(): void {
+		if (this.initialized) {
+			this.logger.debug("ForceUpdateClient already initialized");
+			return;
+		}
+		this.initialized = true;
+
+		// Load from storage, subscribe to events, and sync with current identity state
 		this.versionStatus = this.getVersionStatusFromStorage();
+		this.logger.debug(`Initialized with version status: ${this.versionStatus.type}`);
 		this.subscribeToIdentity();
+		this.initializeFromCurrentIdentityState();
 		this.subscribeToAppState();
 	}
 
+	private initializeFromCurrentIdentityState() {
+		const currentState = this.identity.getIdentifyState();
+		this.logger.debug(`Current identity state during init: ${currentState.type}`);
+		if (currentState.type === "identified") {
+			this.logger.debug(`Identity already identified, syncing version status from: ${currentState.version_info.status}`);
+			this.updateFromVersionStatus(currentState.version_info.status);
+		} else {
+			this.logger.debug(`Identity not yet identified (${currentState.type}), waiting for identify event`);
+		}
+	}
+
 	private getVersionStatusFromStorage(): VersionStatus {
 		const stored = this.storage.getItem(VERSION_STATUS_STORAGE_KEY);
+
 		if (stored == null) {
+			this.logger.debug("No stored version status, returning initializing");
+			return InitializingVersionStatusSchema.parse({ type: "initializing" });
+		}
+
+		const parsed = VersionStatusSchema.parse(JSON.parse(stored));
+		this.logger.debug(`Parsed version status from storage: ${parsed.type}`);
+
+		// "checking" and "initializing" are transient states - if we restore them, reset to initializing
+		// This can happen if the app was killed during a version check
+		if (parsed.type === "checking" || parsed.type === "initializing") {
+			this.logger.debug(`Found stale '${parsed.type}' state in storage, resetting to initializing`);
+			this.storage.removeItem(VERSION_STATUS_STORAGE_KEY);
 			return InitializingVersionStatusSchema.parse({ type: "initializing" });
 		}
 
-		return VersionStatusSchema.parse(JSON.parse(stored));
+		return parsed;
 	}
 
 	private saveVersionStatusToStorage(status: VersionStatus): void {
@@ -123,10 +165,15 @@ export class ForceUpdateClient {
 
 	private subscribeToIdentity() {
 		this.unsubscribe = this.identity.onIdentifyStateChange((state) => {
-			if (state.type === "identifying") {
-				this.setVersionStatus({ type: "checking" });
-			} else if (state.type === "identified") {
-				this.updateFromVersionStatus(state.version_info.status ?? IdentifyVersionStatusEnum.UP_TO_DATE);
+			this.logger.debug(`Identity state changed: ${state.type}`);
+			switch (state.type) {
+				case "identifying":
+					this.setVersionStatus({ type: "checking" });
+					break;
+				case "identified":
+					this.logger.debug(`Identified with version_info.status: ${state.version_info.status}`);
+					this.updateFromVersionStatus(state.version_info.status ?? IdentifyVersionStatusEnum.UP_TO_DATE);
+					break;
 			}
 		});
 	}
@@ -164,9 +211,22 @@ export class ForceUpdateClient {
 
 	private handleAppStateChange = (nextState: AppStateStatus) => {
 		if (nextState === "active") {
+			this.logger.debug("App state changed to active");
+
+			// If checkCooldownMs is -1, disable checking entirely
+			if (this.options.checkCooldownMs === -1) {
+				this.logger.debug("Version checking disabled (checkCooldownMs = -1)");
+				return;
+			}
+
 			const now = Date.now();
 			const throttleOk = !this.lastForegroundTime || now - this.lastForegroundTime >= this.options.throttleMs;
-			const cooldownOk = !this.lastCheckTime || now - this.lastCheckTime >= this.options.checkCooldownMs;
+
+			// If checkCooldownMs is 0, always allow check (no cooldown)
+			// Otherwise, check if enough time has passed since last successful check
+			const cooldownOk = this.options.checkCooldownMs === 0
+				|| !this.lastCheckTime
+				|| now - this.lastCheckTime >= this.options.checkCooldownMs;
 
 			this.lastForegroundTime = now;
 
@@ -177,11 +237,11 @@ export class ForceUpdateClient {
 	};
 
 	private async checkVersionOnForeground() {
-		this.logger.info("Checking version status on foreground");
+		this.logger.debug("Checking version status on foreground");
 		const result = await this.identity.identify();
 
 		if (!result) {
-			this.logger.info("Skipping version check - not identified");
+			this.logger.debug("Skipping version check - not identified");
 			return;
 		}
 
@@ -203,7 +263,7 @@ export class ForceUpdateClient {
 	}
 
 	private setVersionStatus(newStatus: VersionStatus) {
-		this.logger.info(`Version status changing: ${this.versionStatus.type} -> ${newStatus.type}`);
+		this.logger.debug(`Version status changing: ${this.versionStatus.type} -> ${newStatus.type}`);
 		this.versionStatus = newStatus;
 		this.saveVersionStatusToStorage(newStatus);
 		this.emitter.emit("VERSION_STATUS_CHANGED", newStatus);