@speechmatics/real-time-client-react/dist/index.cjs

React hooks for interacting with the Speechmatics Real-Time API

'use strict';

var react = require('react');
var jsxRuntime = require('react/jsx-runtime');
var realTimeClient = require('@speechmatics/real-time-client');

const RealtimeContext = react.createContext(
  null
);

function useRealtimeTranscription() {
  const context = react.useContext(RealtimeContext);
  if (context === null) {
    throw new Error("Flow client uninitialized in context");
  }
  const { client, sessionId, socketState } = context;
  const startTranscription = react.useCallback(
    (jwt, config) => {
      return client.start(jwt, config);
    },
    [client]
  );
  const stopTranscription = react.useCallback(() => {
    return client.stopRecognition();
  }, [client]);
  const sendAudio = react.useCallback(
    (audio) => {
      client.sendAudio(audio);
    },
    [client]
  );
  return react.useMemo(
    () => ({
      sessionId,
      socketState,
      startTranscription,
      stopTranscription,
      sendAudio
    }),
    [sessionId, socketState, startTranscription, stopTranscription, sendAudio]
  );
}

function useRealtimeEventListener(message, cb) {
  const context = react.useContext(RealtimeContext);
  if (context === null) {
    throw new Error("Flow client uninitialized in context");
  }
  return useClientEventListener(context.client, message, cb);
}
function useClientEventListener(client, eventType, cb) {
  return react.useEffect(() => {
    client.addEventListener(eventType, cb);
    return () => client?.removeEventListener(eventType, cb);
  }, [client, eventType, cb]);
}

function RealtimeTranscriptionProvider({
  children,
  ...options
}) {
  const client = react.useMemo(() => {
    return new realTimeClient.RealtimeClient({
      url: options.url,
      appId: options.appId,
      enableLegacy: options.enableLegacy
    });
  }, [options.url, options.appId, options.enableLegacy]);
  react.useEffect(() => {
    return () => {
      if (client.socketState && client.socketState !== "closed") {
        client.stopRecognition();
      }
    };
  }, [client]);
  const socketState = useClientSocketState(client);
  const [sessionId, setSessionId] = react.useState();
  useClientEventListener(client, "receiveMessage", ({ data }) => {
    if (data.message === "Error") {
      console.error(data);
    } else if (data.message === "RecognitionStarted") {
      setSessionId(data.id);
    }
  });
  useClientEventListener(client, "socketStateChange", (e) => {
    if (client.socketState === "closed") {
      setSessionId(void 0);
    }
  });
  const value = react.useMemo(
    () => ({
      client,
      socketState,
      sessionId
    }),
    [client, socketState, sessionId]
  );
  return /* @__PURE__ */ jsxRuntime.jsx(RealtimeContext.Provider, { value, children });
}
function useClientSocketState(client) {
  const subscribe = (onChange) => {
    client.addEventListener("socketStateChange", onChange);
    return () => {
      client.removeEventListener("socketStateChange", onChange);
    };
  };
  const getSnapshot = () => client.socketState;
  return react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
}

exports.RealtimeContext = RealtimeContext;
exports.RealtimeTranscriptionProvider = RealtimeTranscriptionProvider;
exports.useClientEventListener = useClientEventListener;
exports.useRealtimeEventListener = useRealtimeEventListener;
exports.useRealtimeTranscription = useRealtimeTranscription;
Object.keys(realTimeClient).forEach(function (k) {
  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
    enumerable: true,
    get: function () { return realTimeClient[k]; }
  });
});
//# sourceMappingURL=index.cjs.map