@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/chunk-TBUEXRFQ.cjs

@@ -0,0 +1,318 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkIUIRVKJIcjs = require('./chunk-IUIRVKJI.cjs');
+
+
+var _chunk7OX2DSKIcjs = require('./chunk-7OX2DSKI.cjs');
+
+// 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
+var _react = require('react');
+function useLatest(value) {
+  const ref = _react.useRef.call(void 0, value);
+  ref.current = value;
+  return ref;
+}
+function PickleballAutoResume(props) {
+  const {
+    provider,
+    resumeInput,
+    enabled = true,
+    sessionIdHint = null,
+    retryDelayMs = resumeRetryDelayMs,
+    onAttempt
+  } = props;
+  const live = _chunkIUIRVKJIcjs.useLivestream.call(void 0, );
+  const { engine } = _chunkIUIRVKJIcjs.useLivestreamHost.call(void 0, );
+  const goneRef = _react.useRef.call(void 0, null);
+  const attemptRef = _react.useRef.call(void 0, 0);
+  const [retryTick, setRetryTick] = _react.useState.call(void 0, 0);
+  const { state, sessionId, adoptableSessionId } = live;
+  const resumeId = _nullishCoalesce(adoptableSessionId, () => ( sessionIdHint));
+  const liveRef = useLatest(live);
+  const onAttemptRef = useLatest(onAttempt);
+  const resumeInputRef = useLatest(resumeInput);
+  const retryDelayRef = useLatest(retryDelayMs);
+  _react.useEffect.call(void 0, () => {
+    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;
+      _optionalChain([onAttemptRef, 'access', _ => _.current, 'optionalCall', _2 => _2(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: _nullishCoalesce(_optionalChain([resumeInput2, 'access', _3 => _3.titleFor, 'optionalCall', _4 => _4(resumeId)]), () => ( "Phi\xEAn \u0111ang kh\xF4i ph\u1EE5c")),
+          consentVersion: resumeInput2.consentVersion,
+          visibility: _nullishCoalesce(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(() => {
+        _optionalChain([onAttemptRef, 'access', _5 => _5.current, 'optionalCall', _6 => _6(resumeId, "start_failed")]);
+        if (!cancelled) scheduleRetry();
+      });
+    })();
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [enabled, provider, resumeId, sessionId, state, retryTick, engine, liveRef, onAttemptRef, resumeInputRef, retryDelayRef]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || state !== "error" || sessionId === null) return;
+    const timer = setTimeout(() => {
+      _optionalChain([onAttemptRef, 'access', _7 => _7.current, 'optionalCall', _8 => _8(sessionId, "publish_retry")]);
+      void liveRef.current.retry().catch(() => void 0);
+    }, retryDelayRef.current(attemptRef.current++));
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, liveRef, onAttemptRef, retryDelayRef]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || state !== "error" || sessionId !== null || !adoptableSessionId) return;
+    const timer = setTimeout(() => {
+      _optionalChain([onAttemptRef, 'access', _9 => _9.current, 'optionalCall', _10 => _10(adoptableSessionId, "reprepare")]);
+      void liveRef.current.prepare().catch(() => void 0);
+    }, 2e3);
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, adoptableSessionId, liveRef, onAttemptRef]);
+  _react.useEffect.call(void 0, () => {
+    if (state === "live" || state === "standby") attemptRef.current = 0;
+  }, [state]);
+  return null;
+}
+function PickleballAutoPrepare(props) {
+  const { enabled = true, captureOrientation } = props;
+  const live = _chunkIUIRVKJIcjs.useLivestream.call(void 0, );
+  const { state } = live;
+  const liveRef = useLatest(live);
+  const orientedRef = _react.useRef.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || !captureOrientation || orientedRef.current) return;
+    orientedRef.current = true;
+    void liveRef.current.setCaptureOrientation(captureOrientation).catch(() => void 0);
+  }, [enabled, captureOrientation, liveRef]);
+  _react.useEffect.call(void 0, () => {
+    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 = _chunkIUIRVKJIcjs.useLivestream.call(void 0, );
+  const { state, sessionId, adoptableSessionId } = live;
+  const liveRef = useLatest(live);
+  const armedForRef = _react.useRef.call(void 0, null);
+  const inputRef = useLatest(input);
+  const externalSessionId = input.externalSessionId;
+  const armed = sessionId !== null && armedForRef.current === externalSessionId;
+  _react.useEffect.call(void 0, () => {
+    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
+
+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 (e) {
+    return { ...defaults };
+  }
+}
+function createCameraSettingsStore(options = {}) {
+  const storage = _nullishCoalesce(options.storage, () => ( _chunkIUIRVKJIcjs.createDefaultStorage.call(void 0, )));
+  const key = _nullishCoalesce(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 _react.useSyncExternalStore.call(void 0, store.subscribe, store.get, store.get);
+}
+function cameraSettingsKey(settings) {
+  return `${settings.resolution}:${settings.fps}:${_nullishCoalesce(settings.cameraId, () => ( "default"))}`;
+}
+function rtmpRoomFactoryFor(settings) {
+  return _chunkIUIRVKJIcjs.createRtmpRoomFactory.call(void 0, {
+    frameRate: settings.fps,
+    ...settings.cameraId ? { cameraId: settings.cameraId } : {}
+  });
+}
+
+// src/camera-controls.ts
+function nativeModule() {
+  try {
+    const loaded = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native");
+    const candidate = _nullishCoalesce(_optionalChain([loaded, 'optionalAccess', _11 => _11.default]), () => ( loaded));
+    return candidate && typeof candidate === "object" ? candidate : null;
+  } catch (e2) {
+    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 (e3) {
+    return fallback;
+  }
+}
+function getCameraCapabilities() {
+  return callOptional("getCameraCapabilities", (n) => _optionalChain([n, 'access', _12 => _12.getCameraCapabilities, 'optionalCall', _13 => _13()]), null);
+}
+function setZoom(factor) {
+  return callOptional("setZoom", (n) => _optionalChain([n, 'access', _14 => _14.setZoom, 'optionalCall', _15 => _15(factor)]), void 0);
+}
+function setExposureBias(ev) {
+  return callOptional("setExposureBias", (n) => _optionalChain([n, 'access', _16 => _16.setExposureBias, 'optionalCall', _17 => _17(ev)]), void 0);
+}
+function setFocusLocked(locked) {
+  return callOptional("setFocusLocked", (n) => _optionalChain([n, 'access', _18 => _18.setFocusLocked, 'optionalCall', _19 => _19(locked)]), void 0);
+}
+function setExposureLocked(locked) {
+  return callOptional("setExposureLocked", (n) => _optionalChain([n, 'access', _20 => _20.setExposureLocked, 'optionalCall', _21 => _21(locked)]), void 0);
+}
+function setTorch(enabled) {
+  return callOptional("setTorch", (n) => _optionalChain([n, 'access', _22 => _22.setTorch, 'optionalCall', _23 => _23(enabled)]), void 0);
+}
+function applyAntiFlicker(mode) {
+  return callOptional("setAntiFlicker", (n) => _optionalChain([n, 'access', _24 => _24.setAntiFlicker, 'optionalCall', _25 => _25(mode)]), void 0);
+}
+function requestNativePermissions() {
+  return callOptional("requestPermissions", (n) => _optionalChain([n, 'access', _26 => _26.requestPermissions, 'optionalCall', _27 => _27()]), null);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.classifyResumeStatus = classifyResumeStatus; exports.RESUME_RETRY_DELAYS_MS = RESUME_RETRY_DELAYS_MS; exports.resumeRetryDelayMs = resumeRetryDelayMs; exports.resumeBlocksArm = resumeBlocksArm; exports.resumeExternalSessionId = resumeExternalSessionId; exports.resumeGrantMatches = resumeGrantMatches; exports.PickleballAutoResume = PickleballAutoResume; exports.PickleballAutoPrepare = PickleballAutoPrepare; exports.useStandbySession = useStandbySession; exports.CAMERA_SETTINGS_STORAGE_KEY = CAMERA_SETTINGS_STORAGE_KEY; exports.DEFAULT_CAMERA_SETTINGS = DEFAULT_CAMERA_SETTINGS; exports.parseCameraSettings = parseCameraSettings; exports.createCameraSettingsStore = createCameraSettingsStore; exports.useCameraSettings = useCameraSettings; exports.cameraSettingsKey = cameraSettingsKey; exports.rtmpRoomFactoryFor = rtmpRoomFactoryFor; exports.getCameraCapabilities = getCameraCapabilities; exports.setZoom = setZoom; exports.setExposureBias = setExposureBias; exports.setFocusLocked = setFocusLocked; exports.setExposureLocked = setExposureLocked; exports.setTorch = setTorch; exports.applyAntiFlicker = applyAntiFlicker; exports.requestNativePermissions = requestNativePermissions;