pulse-updates 1.0.0

package/src/usePulseUpdates.ts

@@ -0,0 +1,135 @@
+import { useEffect, useState, useCallback } from 'react';
+import * as PulseUpdates from './PulseUpdates';
+import type { PulseManifest, UpdateCheckResult, UpdateFetchResult } from './types';
+
+export interface UsePulseUpdatesResult {
+  // State
+  isEnabled: boolean;
+  isChecking: boolean;
+  isDownloading: boolean;
+  updateId: string | null;
+  runtimeVersion: string | null;
+  channel: string | null;
+  manifest: PulseManifest | null;
+  isEmbeddedLaunch: boolean;
+  createdAt: Date | null;
+  build: string | null;
+
+  // Available/downloaded updates
+  availableUpdate: PulseManifest | null;
+  downloadedUpdate: PulseManifest | null;
+  error: Error | null;
+
+  // Actions
+  checkForUpdate: () => Promise<UpdateCheckResult>;
+  downloadUpdate: () => Promise<UpdateFetchResult>;
+  reload: () => Promise<void>;
+}
+
+export function usePulseUpdates(): UsePulseUpdatesResult {
+  const [isChecking, setIsChecking] = useState(false);
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [availableUpdate, setAvailableUpdate] = useState<PulseManifest | null>(null);
+  const [downloadedUpdate, setDownloadedUpdate] = useState<PulseManifest | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Refresh state on mount to get latest values after configure
+  useEffect(() => {
+    PulseUpdates.refreshStateAsync().catch(() => {});
+  }, []);
+
+  useEffect(() => {
+    if (!PulseUpdates.isEnabled) return;
+
+    const subscription = PulseUpdates.addUpdateListener((event) => {
+      switch (event.type) {
+        case 'updateAvailable':
+          setAvailableUpdate(event.manifest ?? null);
+          break;
+        case 'updateDownloaded':
+          setDownloadedUpdate(event.manifest ?? null);
+          break;
+        case 'updateError':
+          setError(new Error(event.error ?? 'Unknown error'));
+          break;
+        case 'noUpdateAvailable':
+          setAvailableUpdate(null);
+          break;
+      }
+    });
+
+    return () => subscription.remove();
+  }, []);
+
+  const checkForUpdate = useCallback(async (): Promise<UpdateCheckResult> => {
+    if (!PulseUpdates.isEnabled) {
+      return { isAvailable: false };
+    }
+
+    setIsChecking(true);
+    setError(null);
+
+    try {
+      const result = await PulseUpdates.checkForUpdateAsync();
+      if (result.isAvailable && result.manifest) {
+        setAvailableUpdate(result.manifest);
+      } else {
+        setAvailableUpdate(null);
+      }
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      return { isAvailable: false, failedReason: err.message };
+    } finally {
+      setIsChecking(false);
+    }
+  }, []);
+
+  const downloadUpdate = useCallback(async (): Promise<UpdateFetchResult> => {
+    if (!PulseUpdates.isEnabled) {
+      return { isNew: false };
+    }
+
+    setIsDownloading(true);
+    setError(null);
+
+    try {
+      const result = await PulseUpdates.fetchUpdateAsync();
+      if (result.isNew && result.manifest) {
+        setDownloadedUpdate(result.manifest);
+      }
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      return { isNew: false };
+    } finally {
+      setIsDownloading(false);
+    }
+  }, []);
+
+  const reload = useCallback(async (): Promise<void> => {
+    if (!PulseUpdates.isEnabled) return;
+    await PulseUpdates.reloadAsync();
+  }, []);
+
+  return {
+    isEnabled: PulseUpdates.isEnabled,
+    isChecking,
+    isDownloading,
+    updateId: PulseUpdates.updateId,
+    runtimeVersion: PulseUpdates.runtimeVersion,
+    channel: PulseUpdates.channel,
+    manifest: PulseUpdates.manifest,
+    isEmbeddedLaunch: PulseUpdates.isEmbeddedLaunch,
+    createdAt: PulseUpdates.createdAt,
+    build: PulseUpdates.getUpdateBuild(),
+    availableUpdate,
+    downloadedUpdate,
+    error,
+    checkForUpdate,
+    downloadUpdate,
+    reload,
+  };
+}