@pickleball/expo-sdk 0.1.1 → 1.0.0

package/dist/chunk-7Z7TN5N3.js

@@ -0,0 +1,318 @@
+import {
+  createDefaultStorage,
+  createRtmpRoomFactory,
+  useLivestream,
+  useLivestreamHost
+} from "./chunk-XGP2MN5R.js";
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/resume-policy.ts
+function classifyResumeStatus(status) {
+  if (status === 404 || status === 409 || status === 410) return "gone";
+  if (status >= 200 && status < 300) return "ok";
+  return "retry";
+}
+var RESUME_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
+function resumeRetryDelayMs(attempt) {
+  const index = Math.min(Math.max(attempt, 0), RESUME_RETRY_DELAYS_MS.length - 1);
+  return RESUME_RETRY_DELAYS_MS[index];
+}
+function resumeBlocksArm(input) {
+  if (input.engineSessionId !== null) return false;
+  return input.adoptableSessionId !== null || input.serverSessionId !== null;
+}
+function resumeExternalSessionId(sessionId) {
+  return `resume-${sessionId}`;
+}
+function resumeGrantMatches(externalSessionId, grantSessionId) {
+  return externalSessionId === resumeExternalSessionId(grantSessionId);
+}
+
+// src/auto-resume.tsx
+import { useEffect, useRef, useState } from "react";
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+function PickleballAutoResume(props) {
+  const {
+    provider,
+    resumeInput,
+    enabled = true,
+    sessionIdHint = null,
+    retryDelayMs = resumeRetryDelayMs,
+    onAttempt
+  } = props;
+  const live = useLivestream();
+  const { engine } = useLivestreamHost();
+  const goneRef = useRef(null);
+  const attemptRef = useRef(0);
+  const [retryTick, setRetryTick] = useState(0);
+  const { state, sessionId, adoptableSessionId } = live;
+  const resumeId = adoptableSessionId ?? sessionIdHint;
+  const liveRef = useLatest(live);
+  const onAttemptRef = useLatest(onAttempt);
+  const resumeInputRef = useLatest(resumeInput);
+  const retryDelayRef = useLatest(retryDelayMs);
+  useEffect(() => {
+    if (!enabled) return;
+    if (!resumeId || sessionId !== null || state !== "preview") return;
+    if (goneRef.current === resumeId) return;
+    let cancelled = false;
+    let timer;
+    const scheduleRetry = () => {
+      const delay = retryDelayRef.current(attemptRef.current);
+      attemptRef.current += 1;
+      timer = setTimeout(() => {
+        if (!cancelled) setRetryTick((tick) => tick + 1);
+      }, delay);
+    };
+    void (async () => {
+      const result = await provider.resume(resumeId);
+      if (cancelled) return;
+      onAttemptRef.current?.(resumeId, result.kind);
+      if (result.kind === "gone") {
+        goneRef.current = resumeId;
+        attemptRef.current = 0;
+        void engine.abandonAdoptableSession(resumeId).catch(() => void 0);
+        return;
+      }
+      if (result.kind === "retry") {
+        scheduleRetry();
+        return;
+      }
+      attemptRef.current = 0;
+      provider.adoptResumeGrant(result.grant);
+      const resumeInput2 = resumeInputRef.current;
+      await liveRef.current.start(
+        {
+          externalSessionId: resumeExternalSessionId(resumeId),
+          title: resumeInput2.titleFor?.(resumeId) ?? "Phi\xEAn \u0111ang kh\xF4i ph\u1EE5c",
+          consentVersion: resumeInput2.consentVersion,
+          visibility: resumeInput2.visibility ?? "public",
+          ...resumeInput2.metadata ? { metadata: resumeInput2.metadata } : {}
+        },
+        // Trạng thái lấy từ chính phản hồi refresh, KHÔNG đoán: gán cứng "live" là
+        // camera tự lên sóng khi chủ nó chỉ đang trực sân (18/08/2026).
+        { autoPublish: result.live }
+      ).catch(() => {
+        onAttemptRef.current?.(resumeId, "start_failed");
+        if (!cancelled) scheduleRetry();
+      });
+    })();
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [enabled, provider, resumeId, sessionId, state, retryTick, engine, liveRef, onAttemptRef, resumeInputRef, retryDelayRef]);
+  useEffect(() => {
+    if (!enabled || state !== "error" || sessionId === null) return;
+    const timer = setTimeout(() => {
+      onAttemptRef.current?.(sessionId, "publish_retry");
+      void liveRef.current.retry().catch(() => void 0);
+    }, retryDelayRef.current(attemptRef.current++));
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, liveRef, onAttemptRef, retryDelayRef]);
+  useEffect(() => {
+    if (!enabled || state !== "error" || sessionId !== null || !adoptableSessionId) return;
+    const timer = setTimeout(() => {
+      onAttemptRef.current?.(adoptableSessionId, "reprepare");
+      void liveRef.current.prepare().catch(() => void 0);
+    }, 2e3);
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, adoptableSessionId, liveRef, onAttemptRef]);
+  useEffect(() => {
+    if (state === "live" || state === "standby") attemptRef.current = 0;
+  }, [state]);
+  return null;
+}
+function PickleballAutoPrepare(props) {
+  const { enabled = true, captureOrientation } = props;
+  const live = useLivestream();
+  const { state } = live;
+  const liveRef = useLatest(live);
+  const orientedRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || !captureOrientation || orientedRef.current) return;
+    orientedRef.current = true;
+    void liveRef.current.setCaptureOrientation(captureOrientation).catch(() => void 0);
+  }, [enabled, captureOrientation, liveRef]);
+  useEffect(() => {
+    if (!enabled) return;
+    if (state !== "idle" && state !== "ended") return;
+    void liveRef.current.prepare().catch(() => void 0);
+  }, [enabled, state, liveRef]);
+  return null;
+}
+function useStandbySession(options) {
+  const { input, enabled = true, resumeSessionId = null } = options;
+  const live = useLivestream();
+  const { state, sessionId, adoptableSessionId } = live;
+  const liveRef = useLatest(live);
+  const armedForRef = useRef(null);
+  const inputRef = useLatest(input);
+  const externalSessionId = input.externalSessionId;
+  const armed = sessionId !== null && armedForRef.current === externalSessionId;
+  useEffect(() => {
+    if (!enabled) return;
+    if (state !== "preview" || sessionId !== null) return;
+    if (armedForRef.current === externalSessionId) return;
+    if (resumeBlocksArm({
+      adoptableSessionId,
+      serverSessionId: resumeSessionId,
+      engineSessionId: sessionId
+    })) {
+      return;
+    }
+    armedForRef.current = externalSessionId;
+    void liveRef.current.start(inputRef.current, { autoPublish: false }).catch(() => {
+      armedForRef.current = null;
+    });
+  }, [enabled, state, sessionId, adoptableSessionId, resumeSessionId, externalSessionId, liveRef, inputRef]);
+  return { armed };
+}
+
+// src/camera-settings.ts
+import { useSyncExternalStore } from "react";
+var CAMERA_SETTINGS_STORAGE_KEY = "@pickleball/expo-sdk/camera-settings";
+var DEFAULT_CAMERA_SETTINGS = Object.freeze({
+  resolution: 720,
+  fps: 30,
+  antiFlicker: "50hz",
+  cameraId: null
+});
+function parseCameraSettings(raw, defaults = DEFAULT_CAMERA_SETTINGS) {
+  if (!raw) return { ...defaults };
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") return { ...defaults };
+    return {
+      resolution: parsed.resolution === 1080 ? 1080 : parsed.resolution === 720 ? 720 : defaults.resolution,
+      fps: parsed.fps === 24 || parsed.fps === 30 || parsed.fps === 60 ? parsed.fps : defaults.fps,
+      antiFlicker: parsed.antiFlicker === "auto" || parsed.antiFlicker === "60hz" || parsed.antiFlicker === "50hz" ? parsed.antiFlicker : defaults.antiFlicker,
+      cameraId: typeof parsed.cameraId === "string" ? parsed.cameraId : null
+    };
+  } catch {
+    return { ...defaults };
+  }
+}
+function createCameraSettingsStore(options = {}) {
+  const storage = options.storage ?? createDefaultStorage();
+  const key = options.key ?? CAMERA_SETTINGS_STORAGE_KEY;
+  const defaults = { ...DEFAULT_CAMERA_SETTINGS, ...options.defaults };
+  let settings = { ...defaults };
+  let restored = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    key,
+    get: () => settings,
+    set(patch) {
+      settings = { ...settings, ...patch };
+      void storage.setItem(key, JSON.stringify(settings)).catch(() => void 0);
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async restore() {
+      const raw = await storage.getItem(key).catch(() => null);
+      settings = parseCameraSettings(raw, defaults);
+      restored = true;
+      emit();
+    },
+    isRestored: () => restored
+  };
+}
+function useCameraSettings(store) {
+  return useSyncExternalStore(store.subscribe, store.get, store.get);
+}
+function cameraSettingsKey(settings) {
+  return `${settings.resolution}:${settings.fps}:${settings.cameraId ?? "default"}`;
+}
+function rtmpRoomFactoryFor(settings) {
+  return createRtmpRoomFactory({
+    frameRate: settings.fps,
+    ...settings.cameraId ? { cameraId: settings.cameraId } : {}
+  });
+}
+
+// src/camera-controls.ts
+function nativeModule() {
+  try {
+    const loaded = __require("@pickleball/rtmp-native");
+    const candidate = loaded?.default ?? loaded;
+    return candidate && typeof candidate === "object" ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+async function callOptional(name, invoke, fallback) {
+  const native = nativeModule();
+  if (!native || typeof native[name] !== "function") return fallback;
+  try {
+    const result = await invoke(native);
+    return result === void 0 ? fallback : result;
+  } catch {
+    return fallback;
+  }
+}
+function getCameraCapabilities() {
+  return callOptional("getCameraCapabilities", (n) => n.getCameraCapabilities?.(), null);
+}
+function setZoom(factor) {
+  return callOptional("setZoom", (n) => n.setZoom?.(factor), void 0);
+}
+function setExposureBias(ev) {
+  return callOptional("setExposureBias", (n) => n.setExposureBias?.(ev), void 0);
+}
+function setFocusLocked(locked) {
+  return callOptional("setFocusLocked", (n) => n.setFocusLocked?.(locked), void 0);
+}
+function setExposureLocked(locked) {
+  return callOptional("setExposureLocked", (n) => n.setExposureLocked?.(locked), void 0);
+}
+function setTorch(enabled) {
+  return callOptional("setTorch", (n) => n.setTorch?.(enabled), void 0);
+}
+function applyAntiFlicker(mode) {
+  return callOptional("setAntiFlicker", (n) => n.setAntiFlicker?.(mode), void 0);
+}
+function requestNativePermissions() {
+  return callOptional("requestPermissions", (n) => n.requestPermissions?.(), null);
+}
+
+export {
+  classifyResumeStatus,
+  RESUME_RETRY_DELAYS_MS,
+  resumeRetryDelayMs,
+  resumeBlocksArm,
+  resumeExternalSessionId,
+  resumeGrantMatches,
+  PickleballAutoResume,
+  PickleballAutoPrepare,
+  useStandbySession,
+  CAMERA_SETTINGS_STORAGE_KEY,
+  DEFAULT_CAMERA_SETTINGS,
+  parseCameraSettings,
+  createCameraSettingsStore,
+  useCameraSettings,
+  cameraSettingsKey,
+  rtmpRoomFactoryFor,
+  getCameraCapabilities,
+  setZoom,
+  setExposureBias,
+  setFocusLocked,
+  setExposureLocked,
+  setTorch,
+  applyAntiFlicker,
+  requestNativePermissions
+};