@connectifi/agent-react
Version:
Connectifi Agent for react
281 lines (277 loc) • 8.94 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
AgentContext: () => AgentContext,
AgentImportContext: () => AgentImportContext,
AgentImportProvider: () => AgentImportProvider,
AgentProvider: () => AgentProvider,
useConnectifiAgent: () => useConnectifiAgent
});
module.exports = __toCommonJS(src_exports);
// src/agent-import-context.tsx
var import_react = __toESM(require("react"), 1);
var AgentImportContext = (0, import_react.createContext)(
void 0
);
function AgentImportProvider({
children,
interopUrl
}) {
const [agentImport, setAgentImport] = (0, import_react.useState)(
void 0
);
(0, import_react.useEffect)(() => {
if (interopUrl) {
import(
/* webpackIgnore: true */
`${interopUrl}/agent/main.bundle.js`
).then((agent) => {
setAgentImport({
module: agent,
interopUrl
});
});
}
}, [interopUrl]);
return /* @__PURE__ */ import_react.default.createElement(AgentImportContext.Provider, { value: agentImport }, children);
}
// src/agent-context.tsx
var import_react2 = __toESM(require("react"), 1);
var AgentContext = (0, import_react2.createContext)(
void 0
);
function AgentProvider({
children,
agent
}) {
return /* @__PURE__ */ import_react2.default.createElement(AgentContext.Provider, { value: agent }, children);
}
// src/useConnectifiAgent.tsx
var import_react3 = __toESM(require("react"), 1);
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 = (0, import_react3.useContext)(AgentImportContext);
const [state, dispatch] = (0, import_react3.useReducer)(AgentStateReducer, "initial");
const [fdc3, setFDC3] = (0, import_react3.useState)(void 0);
const [resolver, setResolver] = (0, import_react3.useState)(
void 0
);
const [authenticator, setAuthenticator] = (0, import_react3.useState)(void 0);
const [directoryProps, setDirectoryProps] = (0, import_react3.useState)(void 0);
const [sessionOwner, setSessionOwner] = (0, import_react3.useState)(
void 0
);
const [anchorElement, setAnchorElement] = (0, import_react3.useState)(
void 0
);
const [localHandlers, setLocalHandlers] = (0, import_react3.useState)(/* @__PURE__ */ new Map());
const [channels, setChannels] = (0, import_react3.useState)([]);
const [currentChannelId, setCurrentChannelId] = (0, import_react3.useState)(
void 0
);
const [storageAccess, setStorageAccess] = (0, import_react3.useState)(void 0);
const [errorMessage, setErrorMessage] = (0, import_react3.useState)(
void 0
);
const [hasBeenConnected, setHasBeenConnected] = (0, import_react3.useState)(false);
const [reconnectingIn, setReconnectingIn] = (0, import_react3.useState)(-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__ */ import_react3.default.createElement("div", { dangerouslySetInnerHTML: { __html: button.outerHTML } });
setStorageAccess({ button: buttonNode });
const success = await waitForStorageAccess();
if (!success) {
await requestConsent("sameWindow");
}
resetStorageAccess();
};
const createTheAgent = (0, import_react3.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]);
(0, import_react3.useEffect)(() => {
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
};
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
AgentContext,
AgentImportContext,
AgentImportProvider,
AgentProvider,
useConnectifiAgent
});
//# sourceMappingURL=index.cjs.map