@connectifi/agent-react/dist/index.js

Connectifi Agent for react

// src/agent-import-context.tsx
import React, { createContext, useEffect, useState } from "react";
var AgentImportContext = createContext(
  void 0
);
function AgentImportProvider({
  children,
  interopUrl
}) {
  const [agentImport, setAgentImport] = useState(
    void 0
  );
  useEffect(() => {
    if (interopUrl) {
      import(
        /* webpackIgnore: true */
        `${interopUrl}/agent/main.bundle.js`
      ).then((agent) => {
        setAgentImport({
          module: agent,
          interopUrl
        });
      });
    }
  }, [interopUrl]);
  return /* @__PURE__ */ React.createElement(AgentImportContext.Provider, { value: agentImport }, children);
}

// src/agent-context.tsx
import React2, { createContext as createContext2 } from "react";
var AgentContext = createContext2(
  void 0
);
function AgentProvider({
  children,
  agent
}) {
  return /* @__PURE__ */ React2.createElement(AgentContext.Provider, { value: agent }, children);
}

// src/useConnectifiAgent.tsx
import React3, {
  useCallback,
  useContext,
  useEffect as useEffect2,
  useReducer,
  useState as useState2
} from "react";
var AgentStateReducer = (state, event) => {
  switch (state) {
    case "initial":
      if (event === "connect") return "connected";
      if (event === "auth-challenge") return "wait-for-auth";
      if (event === "error") return "error";
      break;
    case "wait-for-auth":
      if (event === "connect") return "connected";
      if (event === "error") return "error";
      break;
    case "connected":
      if (event === "disconnect") return "reconnecting";
      break;
    case "reconnecting":
      if (event === "connect") return "connected";
      if (event === "disconnect-fatal") return "disconnected";
      break;
  }
  return state;
};
function useConnectifiAgent({
  appId,
  customAuthenticator
}) {
  const iframeEmbedErrorPrefix = "failed to embed iframe: ";
  const agentImport = useContext(AgentImportContext);
  const [state, dispatch] = useReducer(AgentStateReducer, "initial");
  const [fdc3, setFDC3] = useState2(void 0);
  const [resolver, setResolver] = useState2(
    void 0
  );
  const [authenticator, setAuthenticator] = useState2(void 0);
  const [directoryProps, setDirectoryProps] = useState2(void 0);
  const [sessionOwner, setSessionOwner] = useState2(
    void 0
  );
  const [anchorElement, setAnchorElement] = useState2(
    void 0
  );
  const [localHandlers, setLocalHandlers] = useState2(/* @__PURE__ */ new Map());
  const [channels, setChannels] = useState2([]);
  const [currentChannelId, setCurrentChannelId] = useState2(
    void 0
  );
  const [storageAccess, setStorageAccess] = useState2(void 0);
  const [errorMessage, setErrorMessage] = useState2(
    void 0
  );
  const [hasBeenConnected, setHasBeenConnected] = useState2(false);
  const [reconnectingIn, setReconnectingIn] = useState2(-1);
  const resetResolver = () => {
    setResolver(void 0);
  };
  const resetAuthenticator = () => {
    setAuthenticator(void 0);
  };
  const resetStorageAccess = () => {
    setStorageAccess(void 0);
  };
  const handleIntentResolution = (message, callback, closeCallback) => {
    setResolver({
      resolutionType: message.resolutionType,
      context: message.context,
      data: message.data,
      resolve: (props) => {
        callback(props);
        resetResolver();
      },
      cancel: () => {
        closeCallback();
        resetResolver();
      }
    });
  };
  const handleAuthenticate = async (authConf) => {
    const { authenticate, ...dirProps } = authConf;
    setDirectoryProps(dirProps);
    dispatch("auth-challenge");
    return new Promise((resolve, reject) => {
      setAuthenticator({
        resolve: () => {
          resetAuthenticator();
          if (customAuthenticator) {
            customAuthenticator(authConf).then(resolve);
          } else {
            authenticate().then(resolve);
          }
        },
        cancel: () => {
          resetAuthenticator();
          reject(new Error("auth canceled"));
          dispatch("error");
        }
      });
    });
  };
  const handleRequestStorageAccess = async ({
    button,
    waitForStorageAccess,
    requestConsent
  }) => {
    const buttonNode = /* @__PURE__ */ React3.createElement("div", { dangerouslySetInnerHTML: { __html: button.outerHTML } });
    setStorageAccess({ button: buttonNode });
    const success = await waitForStorageAccess();
    if (!success) {
      await requestConsent("sameWindow");
    }
    resetStorageAccess();
  };
  const createTheAgent = useCallback(async () => {
    const agentConfig = {
      bridgeGlobal: true,
      logLevel: "debug",
      headless: true,
      handleIntentResolution,
      handleAuthenticate,
      handleRequestStorageAccess,
      onSessionStarted: (props, user) => {
        setDirectoryProps(props);
        setSessionOwner(user);
      },
      onSessionError: (errorMsg) => {
        dispatch("error");
        setErrorMessage(errorMsg);
      },
      onConnected: () => {
        dispatch("connect");
        setReconnectingIn(0);
      },
      onDisconnected: (reconnectingIn2) => {
        if (!reconnectingIn2) {
          dispatch("disconnect-fatal");
        } else {
          dispatch("disconnect");
          setHasBeenConnected(true);
          setReconnectingIn(reconnectingIn2);
        }
      },
      onFDC3Ready: (api) => {
        api.getUserChannels().then((chans) => setChannels(chans));
      },
      onChannelJoined: (chanId) => {
        setCurrentChannelId(chanId);
      },
      onChannelLeft: () => setCurrentChannelId(void 0)
    };
    if (agentImport) {
      const { createAgent } = agentImport.module;
      const api = await createAgent(agentImport.interopUrl, appId, agentConfig);
      return api;
    }
    return void 0;
  }, [agentImport, appId]);
  useEffect2(() => {
    createTheAgent().then((fdc32) => {
      if (!fdc32) {
        return;
      }
      console.log("setting FDC3 for the children");
      setFDC3(fdc32);
    }).catch((e) => {
      console.error(`error creating agent - ${e.message}`);
      let errorMessage2 = e.message;
      if (errorMessage2.startsWith(iframeEmbedErrorPrefix)) {
        errorMessage2 = errorMessage2.substring(iframeEmbedErrorPrefix.length);
      }
      dispatch("error");
      setErrorMessage(errorMessage2);
    });
  }, [createTheAgent]);
  return {
    fdc3,
    resolver,
    authenticator,
    anchorElement,
    setAnchorElement,
    localHandlers,
    setLocalHandlers,
    directoryProps,
    state,
    channels,
    currentChannelId,
    sessionOwner,
    storageAccess,
    errorMessage,
    reconnectingIn,
    hasBeenConnected
  };
}
export {
  AgentContext,
  AgentImportContext,
  AgentImportProvider,
  AgentProvider,
  useConnectifiAgent
};
//# sourceMappingURL=index.js.map