@q9labsai/chalk-react-native 4.1.17 → 5.0.1

package/dist/android.js

@@ -1,62 +0,0 @@
-import {
-  Chalk,
-  ChalkProvider,
-  Entrance,
-  Logo,
-  buildChalkInviteLink,
-  useCan,
-  useChat,
-  useConnection,
-  useMedia,
-  useParticipants,
-  useReactions,
-  useRecording,
-  useSelf,
-  useSpaceClient,
-  useWhiteboard
-} from "./chunk-ITLUHTVS.js";
-import {
-  THEME_PALETTES,
-  THEME_TEXTURES,
-  getThemeMode,
-  isDarkThemePalette,
-  resolveNativeAppearance
-} from "./chunk-5DQ4KBRH.js";
-import {
-  Theme,
-  createNativeTheme
-} from "./chunk-JB4LNWVP.js";
-import "./chunk-2OS7SSXE.js";
-import "./chunk-F3NPRVHO.js";
-import {
-  extractSpaceInviteFromLink,
-  getClipboardInviteSuggestion,
-  parseSpaceInviteLink
-} from "./chunk-4L5GXJ36.js";
-export {
-  Chalk,
-  ChalkProvider,
-  Entrance,
-  Logo,
-  THEME_PALETTES,
-  THEME_TEXTURES,
-  Theme,
-  buildChalkInviteLink,
-  createNativeTheme,
-  extractSpaceInviteFromLink,
-  getClipboardInviteSuggestion,
-  getThemeMode,
-  isDarkThemePalette,
-  parseSpaceInviteLink,
-  resolveNativeAppearance,
-  useCan,
-  useChat,
-  useConnection,
-  useMedia,
-  useParticipants,
-  useReactions,
-  useRecording,
-  useSelf,
-  useSpaceClient,
-  useWhiteboard
-};

package/dist/chunk-2OS7SSXE.js

@@ -1,552 +0,0 @@
-// src/space-client/create-native-space-client.ts
-import {
-  AsyncStorageV1PendingTargetStore,
-  CloudflareRTKClient,
-  CloudflareSFUClient,
-  createChalkChatFileHttpTransport,
-  createChalkWhiteboardV1Client,
-  createChalkWhiteboardV1FileHttpTransport,
-  createCloudflareSFUHTTPTransport,
-  createReactNativeSyncLifecycle,
-  createReactNativeWebSocketFactory,
-  createV1SyncClient
-} from "@q9labsai/chalk-client";
-import { createSpaceClientForPlatform } from "@q9labsai/chalk-client/effect";
-import { RTCPeerConnection, mediaDevices } from "@cloudflare/react-native-webrtc";
-import { AppState } from "react-native";
-
-// src/telemetry.ts
-import { syncTelemetryCorrelation } from "@q9labsai/chalk-client/telemetry";
-var rtcStateEvents = ["connectionstatechange", "iceconnectionstatechange", "signalingstatechange"];
-var nativeJourneyContexts = /* @__PURE__ */ new WeakMap();
-async function authenticatedNativeCredential(credential, journey) {
-  const value = await credential();
-  try {
-    journey?.setAuthenticatedTelemetryHeaders?.({ Authorization: `Bearer ${value}` });
-  } catch {
-  }
-  return value;
-}
-function bindNativeAuthenticatedTelemetry(client, journey) {
-  const setHeaders = journey?.setAuthenticatedTelemetryHeaders;
-  if (!setHeaders) return;
-  const clear = () => {
-    try {
-      setHeaders(void 0);
-    } catch {
-    }
-  };
-  const onSnapshot = () => {
-    const status = client.getSnapshot().connection.status;
-    if (status === "idle" || status === "failed" || status === "left") clear();
-  };
-  const unsubscribe = client.subscribe(onSnapshot);
-  let disposed = false;
-  const originalDispose = client.dispose;
-  client.dispose = () => {
-    if (disposed) return;
-    disposed = true;
-    clear();
-    unsubscribe();
-    originalDispose();
-  };
-}
-function registerNativeJourneyContext(client, journey, telemetry) {
-  if (!journey || !telemetry) return;
-  nativeJourneyContexts.set(client, {
-    journeyId: journey.context.journeyId,
-    traceparent: journey.context.traceparent,
-    ...journey.context.tracestate ? { tracestate: journey.context.tracestate } : {},
-    recordWhiteboardMetric: telemetry.recordWhiteboardMetric
-  });
-}
-function getNativeJourneyContext(client) {
-  return nativeJourneyContexts.get(client);
-}
-function createTelemetry(journey) {
-  const connection = {
-    apiHeaders: journey.headers,
-    context: journey.context,
-    syncCorrelation: syncTelemetryCorrelation(journey.context)
-  };
-  return {
-    connection,
-    observePeerConnection(peerConnection) {
-      return observeNativeRtc(peerConnection, journey);
-    },
-    recordSyncFrame(observation) {
-      journey.recordSyncFrame(observation);
-    },
-    recordWhiteboardMetric(metric) {
-      journey.recordDiagnostic({
-        category: "whiteboard_renderer",
-        code: metric.name,
-        metricValue: metric.value,
-        phase: "media",
-        state: isFailedWhiteboardMetric(metric.name) ? "failed" : "observed"
-      });
-    }
-  };
-}
-function syncTransportCloseDiagnostic(event) {
-  const code = typeof event.code === "number" ? event.code : null;
-  const reason = typeof event.reason === "string" ? event.reason : "";
-  return {
-    category: "network",
-    code: code === null ? "sync_websocket_closed_unknown" : `sync_websocket_closed_${code}_${syncCloseReason(reason)}`,
-    phase: "signaling",
-    state: code === 1e3 ? "observed" : "failed"
-  };
-}
-function syncCloseReason(reason) {
-  switch (reason) {
-    case "authentication failed":
-    case "heartbeat timeout":
-    case "hello timeout":
-    case "invalid token":
-    case "policy violation":
-    case "space actions unsupported":
-    case "text frames only":
-    case "transport error":
-      return reason.replaceAll(" ", "_");
-    default:
-      return reason ? "other" : "none";
-  }
-}
-function isFailedWhiteboardMetric(name) {
-  return name.endsWith(".failure") || name.endsWith(".termination");
-}
-function observeNativeRtc(peerConnection, journey) {
-  let disposed = false;
-  const dispose = () => {
-    if (disposed) return;
-    disposed = true;
-    for (const event of rtcStateEvents) peerConnection.removeEventListener(event, capture);
-  };
-  const capture = () => {
-    void peerConnection.getStats().then((stats) => journey.recordRtcSummary(rtcConnectionState(peerConnection), rtcStats(stats))).catch(() => void 0);
-    if (peerConnection.connectionState === "closed") dispose();
-  };
-  for (const event of rtcStateEvents) peerConnection.addEventListener(event, capture);
-  capture();
-  return dispose;
-}
-function rtcConnectionState(peerConnection) {
-  return {
-    connectionState: peerConnection.connectionState,
-    iceConnectionState: peerConnection.iceConnectionState,
-    signalingState: peerConnection.signalingState
-  };
-}
-function rtcStats(stats) {
-  if (Array.isArray(stats)) return stats.filter(isRtcStatsLike);
-  if (isIterable(stats)) return Array.from(stats, statsValue).filter(isRtcStatsLike);
-  if (hasForEach(stats)) return forEachStats(stats);
-  if (isObject(stats)) return Object.values(stats).filter(isRtcStatsLike);
-  return [];
-}
-function isIterable(value) {
-  return isObject(value) && Symbol.iterator in value;
-}
-function hasForEach(value) {
-  return isObject(value) && "forEach" in value && typeof value.forEach === "function";
-}
-function forEachStats(stats) {
-  const entries = [];
-  stats.forEach((entry) => {
-    if (isRtcStatsLike(entry)) entries.push(entry);
-  });
-  return entries;
-}
-function statsValue(entry) {
-  return Array.isArray(entry) ? entry[1] : entry;
-}
-function isRtcStatsLike(value) {
-  return isObject(value) && typeof value.type === "string";
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/space-client/cloudflare-rtk-native.ts
-var createNativeRealtimeKitClient = async ({ authToken, onError }) => {
-  const { default: NativeRealtimeKitClient } = await import("@cloudflare/realtimekit-react-native");
-  const client = await NativeRealtimeKitClient.init({
-    authToken,
-    defaults: { audio: false, video: false },
-    onError
-  });
-  return adaptNativeRealtimeKitClient(client);
-};
-function adaptNativeRealtimeKitClient(client) {
-  const self = client.self;
-  return {
-    join: () => client.joinRoom(),
-    leave: () => client.leaveRoom(),
-    self: {
-      get peerId() {
-        return self.peerId;
-      },
-      get audioEnabled() {
-        return self.audioEnabled;
-      },
-      get videoEnabled() {
-        return self.videoEnabled;
-      },
-      get screenShareEnabled() {
-        return self.screenShareEnabled;
-      },
-      get audioTrack() {
-        return self.audioTrack ?? null;
-      },
-      get videoTrack() {
-        return self.videoTrack ?? null;
-      },
-      get screenShareTracks() {
-        return {
-          ...self.screenShareTracks.audio ? { audio: self.screenShareTracks.audio } : {},
-          ...self.screenShareTracks.video ? { video: self.screenShareTracks.video } : {}
-        };
-      },
-      enableAudio: () => self.enableAudio(),
-      enableVideo: () => self.enableVideo(),
-      enableScreenShare: () => self.enableScreenShare(),
-      disableAudio: () => self.disableAudio(),
-      disableVideo: () => self.disableVideo(),
-      disableScreenShare: () => self.disableScreenShare(),
-      onAudioUpdate: (listener) => {
-        self.on("audioUpdate", listener);
-        return () => self.off("audioUpdate", listener);
-      },
-      onVideoUpdate: (listener) => {
-        self.on("videoUpdate", listener);
-        return () => self.off("videoUpdate", listener);
-      },
-      onScreenShareUpdate: (listener) => {
-        self.on("screenShareUpdate", listener);
-        return () => self.off("screenShareUpdate", listener);
-      },
-      onLeft: (listener) => {
-        const callback = () => listener();
-        self.on("roomLeft", callback);
-        return () => self.off("roomLeft", callback);
-      }
-    },
-    participants: {
-      joined: {
-        list: () => client.participants.joined.toArray().map(toParticipant),
-        onJoined: (listener) => {
-          const callback = (participant) => listener(toParticipant(participant));
-          client.participants.joined.on("participantJoined", callback);
-          return () => client.participants.joined.off("participantJoined", callback);
-        },
-        onLeft: (listener) => {
-          const callback = (participant) => listener(toParticipant(participant));
-          client.participants.joined.on("participantLeft", callback);
-          return () => client.participants.joined.off("participantLeft", callback);
-        }
-      }
-    }
-  };
-}
-function toParticipant(participant) {
-  return {
-    id: participant.id,
-    userId: participant.userId,
-    ...participant.customParticipantId === void 0 ? {} : { customParticipantId: participant.customParticipantId },
-    audioEnabled: participant.audioEnabled,
-    videoEnabled: participant.videoEnabled,
-    screenShareEnabled: participant.screenShareEnabled,
-    audioTrack: participant.audioTrack ?? null,
-    videoTrack: participant.videoTrack ?? null,
-    screenShareTracks: {
-      ...participant.screenShareTracks.audio ? { audio: participant.screenShareTracks.audio } : {},
-      ...participant.screenShareTracks.video ? { video: participant.screenShareTracks.video } : {}
-    }
-  };
-}
-
-// src/space-client/create-native-space-client.ts
-function createNativeSpaceClient(options) {
-  const { storage, telemetry: journey } = options;
-  const apiBaseURL = options.baseUrl ?? "https://api.chalkmeet.com";
-  const syncURL = options.syncUrl ?? defaultSyncURL(apiBaseURL);
-  const telemetry = journey ? createTelemetry(journey) : void 0;
-  const fetch = telemetryFetch(journey);
-  const lifecycle = createReactNativeSyncLifecycle({ appState: AppState });
-  const webSocket = createReactNativeWebSocketFactory(nativeWebSocketConstructor(journey));
-  const dependencies = {
-    clock: {
-      now: () => Date.now(),
-      setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
-      clearTimeout: (handle) => globalThis.clearTimeout(handle)
-    },
-    mediaDevices: {
-      getUserMedia: async (constraints) => await mediaDevices.getUserMedia(constraints),
-      getDisplayMedia: async () => await mediaDevices.getDisplayMedia()
-    },
-    createMediaClient: (input) => createMediaClient(apiBaseURL, input, fetch, telemetry?.observePeerConnection, journey),
-    createSyncClient: (input) => createSyncClient(syncURL, input, lifecycle, webSocket, storage),
-    createChatFileTransport: (input) => createChatFileTransport(apiBaseURL, input, fetch),
-    createWhiteboardClient: options.whiteboardURL === null ? void 0 : (input) => createWhiteboardClient(apiBaseURL, options.whiteboardURL ?? whiteboardURL(syncURL), input, fetch, lifecycle, webSocket),
-    subscribeForeground: (listener) => {
-      const subscription = AppState.addEventListener("change", (state) => {
-        if (state === "active") listener();
-      });
-      return () => subscription.remove();
-    }
-  };
-  const client = createSpaceClientForPlatform(
-    { space: options.space, getAccess: options.getAccess, baseUrl: apiBaseURL },
-    {
-      apiBaseUrl: apiBaseURL,
-      syncUrl: syncURL,
-      whiteboardUrl: options.whiteboardURL,
-      telemetry: journey?.context,
-      dependencies,
-      fetch,
-      syncStartupTimeoutMs: options.syncStartupTimeoutMs ?? 3e4,
-      initialMicrophoneEnabled: options.microphone,
-      initialCameraEnabled: options.camera,
-      onConnectionDiagnostic: (event) => journey?.recordDiagnostic(connectionDiagnostic(event)),
-      ...journey ? { recordReconnect: (observation) => journey.recordDiagnostic(observation) } : {},
-      feedbackSource: options.feedbackSource ?? "embedded"
-    }
-  );
-  bindNativeAuthenticatedTelemetry(client, journey);
-  registerNativeJourneyContext(client, journey, telemetry);
-  return client;
-}
-function connectionDiagnostic(event) {
-  if (event.event === "space_join_span" && event.step && event.spanId && event.outcome) {
-    return {
-      category: "connection",
-      code: `space.join.${event.step}.${event.outcome}`,
-      phase: joinTracePhase(event.step),
-      state: event.outcome === "succeeded" ? "succeeded" : event.outcome === "failed" ? "failed" : "observed",
-      ...event.durationMs === void 0 ? {} : { metricValue: event.durationMs },
-      attributes: {
-        span_id: event.spanId,
-        ...event.parentSpanId ? { parent_span_id: event.parentSpanId } : {},
-        step: event.step,
-        outcome: event.outcome,
-        epoch: event.epoch,
-        ...event.code ? { failure_code: event.code } : {}
-      }
-    };
-  }
-  return {
-    category: "connection",
-    code: event.event,
-    phase: event.state === "joining" ? "signaling" : event.state === "leaving" || event.state === "left" ? "terminal" : "recovery",
-    state: event.event.endsWith("_failed") || event.event.endsWith("_exhausted") ? "failed" : "observed"
-  };
-}
-function joinTracePhase(step) {
-  switch (step) {
-    case "acquire_initial_media":
-    case "create_media_client":
-    case "start_media":
-      return "media";
-    default:
-      return "signaling";
-  }
-}
-function createMediaClient(apiBaseURL, input, fetch, observePeerConnection, journey) {
-  const { subject } = input.access;
-  if (input.access.media.provider === "cloudflare_rtk") {
-    const client2 = new CloudflareRTKClient({
-      authToken: input.access.media.clientPayload.token,
-      participantId: subject.participantId,
-      clientFactory: createNativeRealtimeKitClient,
-      onError: input.onFailure,
-      onScreenEnded: input.onScreenEnded
-    });
-    return createRTKConnectionMediaClient(client2);
-  }
-  const replaceMediaConnection = input.replaceMediaConnection;
-  const client = new CloudflareSFUClient({
-    bootstrap: input.access.media.clientPayload,
-    participantId: subject.participantId,
-    transport: createCloudflareSFUHTTPTransport({
-      apiBaseURL,
-      telemetry: input.telemetry,
-      credential: () => authenticatedNativeCredential(input.credential, journey),
-      tenantId: subject.tenantId,
-      spaceId: subject.spaceId,
-      episodeId: subject.episodeId,
-      participantId: subject.participantId,
-      fetch
-    }),
-    replaceMediaConnection: replaceMediaConnection ? async () => {
-      const replacement = await replaceMediaConnection();
-      if (replacement.provider !== "cloudflare_sfu") throw new TypeError("The Cloudflare SFU adapter requires a Cloudflare SFU access grant");
-      return replacement.clientPayload;
-    } : void 0,
-    peerConnectionFactory: (configuration) => {
-      const connection = new RTCPeerConnection(configuration);
-      observePeerConnection?.(connection);
-      return connection;
-    },
-    recordReconnect: input.recordReconnect,
-    onError: input.onFailure,
-    onScreenEnded: input.onScreenEnded
-  });
-  return createSFUConnectionMediaClient(client);
-}
-function createRTKConnectionMediaClient(client) {
-  return {
-    setLocalPublicationTarget: client.setLocalPublicationTarget.bind(client),
-    observeLocalPublications: client.observeLocalPublications.bind(client),
-    observeRemotePublications: client.observeRemotePublications.bind(client),
-    start: client.start.bind(client),
-    stop: client.stop.bind(client),
-    restart: (input) => {
-      if (!("provider" in input) || input.provider !== "cloudflare_rtk") throw new TypeError("The RealtimeKit adapter requires a Cloudflare RealtimeKit access grant");
-      return client.restart(input);
-    },
-    prepareLocalTrack: client.prepareLocalTrack.bind(client),
-    clearPreparedLocalTrack: client.clearPreparedLocalTrack.bind(client),
-    getSnapshot: client.getSnapshot.bind(client),
-    subscribe: client.subscribe.bind(client)
-  };
-}
-function createSFUConnectionMediaClient(client) {
-  return {
-    setLocalPublicationTarget: client.setLocalPublicationTarget.bind(client),
-    observeLocalPublications: client.observeLocalPublications.bind(client),
-    observeRemotePublications: client.observeRemotePublications.bind(client),
-    start: client.start.bind(client),
-    stop: client.stop.bind(client),
-    restart: (input) => {
-      if ("provider" in input) {
-        if (input.provider !== "cloudflare_sfu") throw new TypeError("The Cloudflare SFU adapter requires a Cloudflare SFU access grant");
-        return client.restart(input.clientPayload);
-      }
-      return client.restart(input);
-    },
-    prepareLocalTrack: client.prepareLocalTrack.bind(client),
-    clearPreparedLocalTrack: client.clearPreparedLocalTrack.bind(client),
-    getSnapshot: client.getSnapshot.bind(client),
-    subscribe: client.subscribe.bind(client)
-  };
-}
-function createSyncClient(syncURL, input, lifecycle, webSocket, storage) {
-  const subject = input.access.subject;
-  const scope = `${subject.tenantId}:${subject.episodeId}:${subject.participantId}`;
-  return createV1SyncClient({
-    url: syncURL,
-    token: input.token,
-    mediaPlane: input.media,
-    lifecycle,
-    webSocket,
-    telemetry: input.telemetry,
-    recordReconnect: input.recordReconnect,
-    ...storage ? { pendingStore: new AsyncStorageV1PendingTargetStore({ scope, storage }) } : {}
-  });
-}
-function createChatFileTransport(apiBaseURL, input, fetch) {
-  return createChalkChatFileHttpTransport({ baseUrl: apiBaseURL, token: input.token, fetch });
-}
-function createWhiteboardClient(apiBaseURL, url, input, fetch, lifecycle, webSocket) {
-  let sceneId = null;
-  const files = createChalkWhiteboardV1FileHttpTransport({
-    baseUrl: apiBaseURL,
-    token: input.token,
-    sceneId: () => {
-      if (sceneId === null) throw new TypeError("Whiteboard scene is not ready");
-      return sceneId;
-    },
-    fetch
-  });
-  return createChalkWhiteboardV1Client({
-    url,
-    token: input.token,
-    files,
-    lifecycle,
-    webSocket,
-    onSummary: (summary) => {
-      sceneId = summary.sceneId;
-      input.onSummary(summary);
-    }
-  });
-}
-function telemetryFetch(journey) {
-  if (!journey) return globalThis.fetch;
-  return (input, init) => {
-    const headers = new Headers(init?.headers);
-    for (const [name, value] of Object.entries(journey.headers)) headers.set(name, value);
-    return globalThis.fetch(input, { ...init, headers });
-  };
-}
-function nativeWebSocketConstructor(journey) {
-  const RuntimeWebSocket = globalThis.WebSocket;
-  return class ChalkNativeWebSocket {
-    onopen = null;
-    onmessage = null;
-    onclose = null;
-    onerror = null;
-    #socket;
-    constructor(url) {
-      this.#socket = new RuntimeWebSocket(url, void 0, journey ? { headers: journey.headers } : void 0);
-      this.#socket.onopen = (event) => this.onopen?.(event);
-      this.#socket.onmessage = (event) => {
-        recordSyncFrame(journey, "server_to_client", event.data);
-        this.onmessage?.(event);
-      };
-      this.#socket.onclose = (event) => {
-        recordSyncTransportClose(journey, event);
-        this.onclose?.(event);
-      };
-      this.#socket.onerror = (event) => {
-        journey?.recordDiagnostic({ category: "network", code: "sync_websocket_error", phase: "signaling", state: "failed" });
-        this.onerror?.(event);
-      };
-    }
-    send(data) {
-      recordSyncFrame(journey, "client_to_server", data);
-      this.#socket.send(data);
-    }
-    close(code, reason) {
-      this.#socket.close(code, reason);
-    }
-  };
-}
-function recordSyncTransportClose(journey, event) {
-  if (!journey) return;
-  journey.recordDiagnostic(syncTransportCloseDiagnostic(event));
-}
-function recordSyncFrame(journey, direction, data) {
-  if (!journey) return;
-  let frameType = "binary";
-  if (typeof data === "string") {
-    try {
-      const frame = JSON.parse(data);
-      frameType = typeof frame.type === "string" ? frame.type : "unknown";
-    } catch {
-      frameType = "invalid_json";
-    }
-  }
-  journey.recordSyncFrame({ direction, frameType });
-}
-function whiteboardURL(syncURL) {
-  const url = new URL(syncURL);
-  url.pathname = "/v1/whiteboard";
-  url.search = "";
-  url.hash = "";
-  return url.toString();
-}
-function defaultSyncURL(apiBaseURL) {
-  const url = new URL(apiBaseURL);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  if (url.hostname.startsWith("api.")) url.hostname = `sync.${url.hostname.slice(4)}`;
-  url.pathname = "/v1/sync";
-  url.search = "";
-  url.hash = "";
-  return url.toString();
-}
-
-export {
-  getNativeJourneyContext,
-  createNativeSpaceClient
-};