@opengeni/react 0.57.0 → 1.0.2-canary.37191796234001

package/dist/chunk-SCOTPE2I.js

@@ -0,0 +1,589 @@
+// src/components/artifacts/published-html-artifact-frame.tsx
+import {
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  isOpenGeniSiteBridgeCancelMessage,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  sanitizeOpenGeniSiteToolCallRequest,
+  isSiteHttpRequest,
+  serveSiteHttp
+} from "@opengeni/sdk/site";
+import { useEffect, useRef, useState } from "react";
+import { resolveSiteClientScript } from "@opengeni/sdk/site-document";
+import { jsx } from "react/jsx-runtime";
+var PUBLISHED_HTML_ARTIFACT_IFRAME_SANDBOX = [
+  "allow-downloads",
+  "allow-forms",
+  "allow-modals",
+  "allow-orientation-lock",
+  "allow-pointer-lock",
+  "allow-popups",
+  "allow-popups-to-escape-sandbox",
+  "allow-presentation",
+  "allow-scripts"
+].join(" ");
+var SITE_BRIDGE_BOOTSTRAP_SCRIPT = `<script>(()=>{const key=${JSON.stringify(
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL
+)};const parentWindow=window.parent;if(parentWindow===window)return;window.addEventListener("message",event=>{const data=event.data;if(event.source!==parentWindow||!data||data.type!==${JSON.stringify(
+  OPENGENI_SITE_BRIDGE_READY
+)}||data.version!==${OPENGENI_SITE_BRIDGE_VERSION}||event.ports.length!==1)return;const port=event.ports[0];const previous=window[key]?.port;if(previous&&previous!==port)previous.close();Object.defineProperty(window,key,{configurable:true,value:{port}});port.start();});})();</script>`;
+function publishedHtmlArtifactDocument(html, toolBridgeEnabled) {
+  if (!toolBridgeEnabled) return html;
+  html = resolveSiteClientScript(html);
+  const doctypeEnd = leadingDoctypeEnd(html);
+  if (doctypeEnd >= 0) {
+    return `${html.slice(0, doctypeEnd + 1)}${SITE_BRIDGE_BOOTSTRAP_SCRIPT}${html.slice(doctypeEnd + 1)}`;
+  }
+  return `${SITE_BRIDGE_BOOTSTRAP_SCRIPT}${html}`;
+}
+function leadingDoctypeEnd(html) {
+  const lower = html.toLowerCase();
+  let cursor = html.charCodeAt(0) === 65279 ? 1 : 0;
+  while (cursor < html.length) {
+    while (/\s/.test(html[cursor] ?? "")) cursor += 1;
+    if (!html.startsWith("<!--", cursor)) break;
+    const commentEnd = html.indexOf("-->", cursor + 4);
+    if (commentEnd < 0) return -1;
+    cursor = commentEnd + 3;
+  }
+  if (!lower.startsWith("<!doctype", cursor)) return -1;
+  return html.indexOf(">", cursor + 9);
+}
+function PublishedHtmlArtifactFrame(props) {
+  const frameRef = useRef(null);
+  const [height, setHeight] = useState();
+  useEffect(() => {
+    if (!props.autoHeight) return;
+    const receive = (event) => {
+      if (event.source !== frameRef.current?.contentWindow || event.data?.type !== "opengeni.preview.height")
+        return;
+      const value = event.data.height;
+      if (typeof value === "number" && Number.isFinite(value))
+        setHeight(Math.min(1200, Math.max(80, value)));
+    };
+    window.addEventListener("message", receive);
+    return () => window.removeEventListener("message", receive);
+  }, [props.autoHeight]);
+  useEffect(() => {
+    frameRef.current?.contentWindow?.postMessage(
+      { type: "opengeni.preview.theme", theme: props.theme },
+      "*"
+    );
+  }, [props.theme]);
+  const bridgeRef = useRef(props.toolBridge);
+  const onFrameLoadRef = useRef(() => void 0);
+  const frameLoadPendingRef = useRef(false);
+  const toolBridgeEnabled = props.toolBridge !== void 0;
+  useEffect(() => {
+    bridgeRef.current = props.toolBridge;
+  }, [props.toolBridge]);
+  useEffect(() => {
+    if (!toolBridgeEnabled || typeof window === "undefined") return;
+    const requests = new SiteBridgeRequestRegistry();
+    const attachToolPort = (data, ports) => {
+      const port = openGeniSiteBridgePortFromBootstrap(data, ports);
+      if (!port) return;
+      requests.addPort(port);
+      port.addEventListener("message", (portEvent) => {
+        const message = portEvent.data;
+        if (isOpenGeniSiteBridgeCancelMessage(message)) {
+          requests.cancel(port, message.requestId);
+          return;
+        }
+        if (isSiteHttpRequest(message) && portEvent.ports.length === 1) {
+          const controller2 = requests.start(port, message.requestId);
+          if (!controller2) {
+            portEvent.ports[0].close();
+            return;
+          }
+          void serveSiteHttp(
+            message,
+            portEvent.ports[0],
+            async (request, signal) => {
+              const fetch = bridgeRef.current?.fetch;
+              if (!fetch) throw new Error("This Site host does not support the session SDK");
+              return fetch(request, signal);
+            },
+            controller2.signal
+          ).finally(() => requests.complete(port, message.requestId, controller2));
+          return;
+        }
+        if (!isOpenGeniSiteBridgeRequestMessage(message)) return;
+        const controller = requests.start(port, message.requestId);
+        if (!controller) {
+          port.postMessage({
+            type: OPENGENI_SITE_BRIDGE_RESPONSE,
+            version: OPENGENI_SITE_BRIDGE_VERSION,
+            requestId: message.requestId,
+            ok: false,
+            error: {
+              code: "duplicate_request_id",
+              message: "A Site tool request with this id is already running",
+              retryable: false
+            }
+          });
+          return;
+        }
+        void handleSiteBridgeRequest(bridgeRef.current, message, controller.signal).then((value) => {
+          if (!controller.signal.aborted) {
+            port.postMessage({
+              type: OPENGENI_SITE_BRIDGE_RESPONSE,
+              version: OPENGENI_SITE_BRIDGE_VERSION,
+              requestId: message.requestId,
+              ok: true,
+              value
+            });
+          }
+        }).catch((error) => {
+          if (!controller.signal.aborted) {
+            port.postMessage({
+              type: OPENGENI_SITE_BRIDGE_RESPONSE,
+              version: OPENGENI_SITE_BRIDGE_VERSION,
+              requestId: message.requestId,
+              ok: false,
+              error: siteBridgeError(error)
+            });
+          }
+        }).finally(() => requests.complete(port, message.requestId, controller));
+      });
+      port.addEventListener("messageerror", () => requests.closePort(port));
+      port.start();
+      port.postMessage({
+        type: OPENGENI_SITE_BRIDGE_READY,
+        version: OPENGENI_SITE_BRIDGE_VERSION
+      });
+    };
+    const documentLease = new SiteBridgeDocumentLease(attachToolPort, () => requests.closeAll());
+    const onFrameLoad = () => {
+      frameLoadPendingRef.current = false;
+      const frameWindow = frameRef.current?.contentWindow ?? null;
+      if (!frameWindow) return;
+      documentLease.load(frameWindow);
+    };
+    onFrameLoadRef.current = onFrameLoad;
+    if (frameLoadPendingRef.current) {
+      frameLoadPendingRef.current = false;
+      onFrameLoad();
+    }
+    return () => {
+      onFrameLoadRef.current = () => void 0;
+      documentLease.close();
+    };
+  }, [props.html, toolBridgeEnabled]);
+  return /* @__PURE__ */ jsx(
+    "iframe",
+    {
+      ref: frameRef,
+      title: props.title,
+      sandbox: PUBLISHED_HTML_ARTIFACT_IFRAME_SANDBOX,
+      referrerPolicy: "no-referrer",
+      srcDoc: publishedHtmlArtifactDocument(props.html, toolBridgeEnabled),
+      onLoad: () => {
+        frameRef.current?.contentWindow?.postMessage(
+          { type: "opengeni.preview.theme", theme: props.theme },
+          "*"
+        );
+        frameLoadPendingRef.current = true;
+        onFrameLoadRef.current();
+      },
+      className: props.className,
+      style: { ...props.style, ...props.autoHeight && height ? { height } : {} }
+    }
+  );
+}
+var SiteBridgeRequestRegistry = class {
+  controllersByPort = /* @__PURE__ */ new Map();
+  addPort(port) {
+    if (!this.controllersByPort.has(port)) this.controllersByPort.set(port, /* @__PURE__ */ new Map());
+  }
+  start(port, requestId) {
+    const controllers = this.controllersByPort.get(port);
+    if (!controllers || controllers.has(requestId)) return null;
+    const controller = new AbortController();
+    controllers.set(requestId, controller);
+    return controller;
+  }
+  cancel(port, requestId) {
+    const controllers = this.controllersByPort.get(port);
+    const controller = controllers?.get(requestId);
+    if (!controller) return;
+    controller.abort(new Error("Site tool request cancelled"));
+    controllers.delete(requestId);
+  }
+  complete(port, requestId, controller) {
+    const controllers = this.controllersByPort.get(port);
+    if (controllers?.get(requestId) === controller) controllers.delete(requestId);
+  }
+  closePort(port) {
+    const controllers = this.controllersByPort.get(port);
+    if (!controllers) return;
+    for (const controller of controllers.values()) {
+      controller.abort(new Error("Site tool bridge port closed"));
+    }
+    controllers.clear();
+    this.controllersByPort.delete(port);
+    port.close();
+  }
+  closeAll() {
+    for (const port of [...this.controllersByPort.keys()]) this.closePort(port);
+  }
+};
+var SiteBridgeDocumentLease = class {
+  constructor(attachToolPort, closeActivePorts, createMessageChannel = () => new MessageChannel()) {
+    this.attachToolPort = attachToolPort;
+    this.closeActivePorts = closeActivePorts;
+    this.createMessageChannel = createMessageChannel;
+  }
+  loaded = false;
+  bootstrapPort = null;
+  load(frameWindow) {
+    if (this.loaded) {
+      this.close();
+      return false;
+    }
+    this.loaded = true;
+    const channel = this.createMessageChannel();
+    this.bootstrapPort = channel.port1;
+    channel.port1.addEventListener("message", (event) => {
+      this.attachToolPort(event.data, event.ports);
+    });
+    channel.port1.start();
+    frameWindow.postMessage(
+      {
+        type: OPENGENI_SITE_BRIDGE_READY,
+        version: OPENGENI_SITE_BRIDGE_VERSION
+      },
+      "*",
+      [channel.port2]
+    );
+    return true;
+  }
+  close() {
+    this.bootstrapPort?.close();
+    this.bootstrapPort = null;
+    this.closeActivePorts();
+  }
+};
+function openGeniSiteBridgePortFromBootstrap(data, ports) {
+  if (!isOpenGeniSiteBridgeConnectMessage(data)) return null;
+  return ports.length === 1 ? ports[0] : null;
+}
+async function handleSiteBridgeRequest(bridge, message, signal) {
+  if (!bridge) throw new Error("Site tool bridge is unavailable");
+  if (message.method === "catalog") return await bridge.catalog({ signal });
+  if (message.method === "declarations") {
+    if (!bridge.declarations) throw new Error("Site tool declarations are unavailable");
+    return await bridge.declarations({ signal });
+  }
+  return await bridge.call(sanitizeOpenGeniSiteToolCallRequest(message.payload), { signal });
+}
+function siteBridgeError(error) {
+  const candidate = error;
+  return {
+    code: typeof candidate?.code === "string" ? candidate.code : "site_tool_call_failed",
+    message: typeof candidate?.message === "string" ? candidate.message : "Site tool request failed",
+    retryable: candidate?.retryable === true,
+    outcomeUnknown: candidate?.outcomeUnknown === true
+  };
+}
+
+// src/sites-ui.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+async function loadSiteSnapshot(client, workspaceId, siteId, options = {}) {
+  const requestOptions = options.signal ? { signal: options.signal } : {};
+  const detail = await client.getWorkspaceArtifact(workspaceId, siteId, requestOptions);
+  options.signal?.throwIfAborted();
+  if (detail.artifact.id !== siteId || detail.artifact.workspaceId !== workspaceId)
+    throw new Error("Site scope mismatch");
+  const selectedVersion = options.versionId ? detail.versions.find((version) => version.id === options.versionId) : detail.artifact.currentVersion;
+  const versionId = options.versionId ?? selectedVersion?.id;
+  let content = selectedVersion && versionId && (detail.artifact.status === "active" || options.includeArchivedContent) ? {
+    artifactId: siteId,
+    versionId,
+    requestedTools: selectedVersion.requestedTools,
+    html: await client.getWorkspaceArtifactHtml(workspaceId, siteId, {
+      ...requestOptions,
+      versionId
+    })
+  } : null;
+  if (versionId && !selectedVersion && (detail.artifact.status === "active" || options.includeArchivedContent)) {
+    if (!client.getWorkspaceArtifactContent) throw new Error("Site version unavailable");
+    content = await client.getWorkspaceArtifactContent(workspaceId, siteId, {
+      ...requestOptions,
+      versionId
+    });
+  }
+  options.signal?.throwIfAborted();
+  if (content && (content.artifactId !== siteId || content.versionId !== versionId))
+    throw new Error("Site content mismatch");
+  return { detail: structuredClone(detail), content: content ? structuredClone(content) : null };
+}
+function useScopeKey(values) {
+  const [scope, setScope] = useState2(values);
+  const [generation, setGeneration] = useState2(0);
+  if (values.some((value, index) => value !== scope[index])) {
+    setScope(values);
+    setGeneration(generation + 1);
+  }
+  return generation;
+}
+function SiteList(props) {
+  const key = useScopeKey([props.client, props.workspaceId, props.status]);
+  return /* @__PURE__ */ jsx2(ScopedSiteList, { ...props }, key);
+}
+function ScopedSiteList({
+  client,
+  workspaceId,
+  status = "active",
+  onOpen,
+  className
+}) {
+  const [page, setPage] = useState2(null);
+  const [cursor, setCursor] = useState2();
+  const [error, setError] = useState2(false);
+  const [reload, setReload] = useState2(0);
+  useEffect2(() => {
+    const abort = new AbortController();
+    setPage(null);
+    setError(false);
+    void Promise.resolve().then(
+      () => client.listWorkspaceArtifacts(workspaceId, {
+        status,
+        ...cursor ? { cursor } : {},
+        limit: 50,
+        signal: abort.signal
+      })
+    ).then((result) => {
+      if (!abort.signal.aborted) setPage(structuredClone(result));
+    }).catch(() => {
+      if (!abort.signal.aborted) setError(true);
+    });
+    return () => abort.abort();
+  }, [client, workspaceId, status, cursor, reload]);
+  return /* @__PURE__ */ jsxs("section", { className, "aria-label": "Sites", "aria-busy": !page && !error, children: [
+    error ? /* @__PURE__ */ jsx2("p", { role: "alert", children: "Sites are unavailable or access has changed. Refresh to check access." }) : !page ? /* @__PURE__ */ jsx2("p", { role: "status", children: "Loading Sites\u2026" }) : page.artifacts.length === 0 ? /* @__PURE__ */ jsxs("p", { role: "status", children: [
+      "No ",
+      status,
+      " Sites."
+    ] }) : /* @__PURE__ */ jsx2("ul", { children: page.artifacts.map((site) => /* @__PURE__ */ jsxs("li", { children: [
+      /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => onOpen(structuredClone(site)), children: site.title }),
+      /* @__PURE__ */ jsx2("p", { children: site.description }),
+      /* @__PURE__ */ jsxs("span", { children: [
+        site.status,
+        " \xB7 revision ",
+        site.currentVersion?.revision ?? "unpublished"
+      ] })
+    ] }, site.id)) }),
+    page?.nextCursor && /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => setCursor(page.nextCursor), children: "Next page" }),
+    cursor && /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => setCursor(void 0), children: "First page" }),
+    /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => setReload((value) => value + 1), children: "Refresh Sites" })
+  ] });
+}
+function SiteDetail(props) {
+  const key = useScopeKey([props.client, props.workspaceId, props.siteId]);
+  return /* @__PURE__ */ jsx2(ScopedSiteDetail, { ...props }, key);
+}
+function ScopedSiteDetail({
+  client,
+  workspaceId,
+  siteId,
+  canPublish = false,
+  toolBridge,
+  className
+}) {
+  const [loaded, setLoaded] = useState2(null);
+  const [error, setError] = useState2(false);
+  const [reload, setReload] = useState2(0);
+  const [busy, setBusy] = useState2(false);
+  const [rollbackId, setRollbackId] = useState2("");
+  const [confirmation, setConfirmation] = useState2(null);
+  const mutation = useRef2(null);
+  useEffect2(() => () => mutation.current?.abort(), []);
+  useEffect2(() => {
+    const abort = new AbortController();
+    setLoaded(null);
+    setError(false);
+    setConfirmation(null);
+    setRollbackId("");
+    void Promise.resolve().then(async () => {
+      const snapshot = await loadSiteSnapshot(client, workspaceId, siteId, {
+        signal: abort.signal
+      });
+      if (!abort.signal.aborted) setLoaded(snapshot);
+    }).catch(() => {
+      if (!abort.signal.aborted) {
+        setLoaded(null);
+        setError(true);
+      }
+    });
+    return () => abort.abort();
+  }, [client, workspaceId, siteId, reload]);
+  useEffect2(() => {
+    if (!loaded || busy) return;
+    const abort = new AbortController();
+    let checking = false;
+    const timer = setInterval(() => {
+      if (checking) return;
+      checking = true;
+      void Promise.resolve().then(() => client.getWorkspaceArtifact(workspaceId, siteId, { signal: abort.signal })).then((detail) => {
+        if (abort.signal.aborted) return;
+        if (detail.artifact.id !== siteId || detail.artifact.workspaceId !== workspaceId)
+          throw new Error("Site scope mismatch");
+        if (detail.artifact.currentVersion?.id !== loaded.detail.artifact.currentVersion?.id || detail.artifact.status !== loaded.detail.artifact.status) {
+          setLoaded(null);
+          setReload((value) => value + 1);
+        }
+      }).catch(() => {
+        if (!abort.signal.aborted) {
+          setLoaded(null);
+          setError(true);
+        }
+      }).finally(() => {
+        checking = false;
+      });
+    }, 15e3);
+    return () => {
+      abort.abort();
+      clearInterval(timer);
+    };
+  }, [client, workspaceId, siteId, loaded, busy]);
+  const commit = async () => {
+    const current = loaded?.detail.artifact.currentVersion;
+    if (!canPublish || !loaded || !current || !confirmation || mutation.current) return;
+    const abort = new AbortController();
+    mutation.current = abort;
+    setBusy(true);
+    try {
+      const common = { expectedCurrentVersionId: current.id, idempotencyKey: crypto.randomUUID() };
+      if (confirmation === "rollback") {
+        if (!loaded.detail.versions.some((version) => version.id === rollbackId))
+          throw new Error("Unknown version");
+        await client.rollbackWorkspaceArtifact(
+          workspaceId,
+          siteId,
+          { ...common, versionId: rollbackId, reason: "Restore explicitly selected Site version" },
+          { signal: abort.signal }
+        );
+      } else {
+        await client.setWorkspaceArtifactStatus(
+          workspaceId,
+          siteId,
+          {
+            ...common,
+            status: loaded.detail.artifact.status === "active" ? "archived" : "active",
+            reason: "Explicit Site status change"
+          },
+          { signal: abort.signal }
+        );
+      }
+      if (!abort.signal.aborted) {
+        setLoaded(null);
+        setReload((value) => value + 1);
+      }
+    } catch {
+      if (!abort.signal.aborted) {
+        setLoaded(null);
+        setError(true);
+      }
+    } finally {
+      if (!abort.signal.aborted) {
+        mutation.current = null;
+        setBusy(false);
+        setConfirmation(null);
+      }
+    }
+  };
+  const site = loaded?.detail.artifact;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className,
+      "aria-label": "Site details",
+      "aria-busy": busy || !loaded && !error,
+      children: [
+        error && /* @__PURE__ */ jsx2("p", { role: "alert", children: "Site state could not be confirmed or access has changed. Refresh before continuing." }),
+        !loaded && !error && /* @__PURE__ */ jsx2("p", { role: "status", children: "Loading Site\u2026" }),
+        site && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx2("h2", { children: site.title }),
+          /* @__PURE__ */ jsx2("p", { children: site.description }),
+          /* @__PURE__ */ jsxs("p", { children: [
+            site.status,
+            " \xB7 revision ",
+            site.currentVersion?.revision ?? "unpublished"
+          ] }),
+          loaded.content && /* @__PURE__ */ jsx2(
+            PublishedHtmlArtifactFrame,
+            {
+              html: loaded.content.html,
+              title: site.title,
+              ...toolBridge ? { toolBridge } : {}
+            }
+          ),
+          /* @__PURE__ */ jsx2("h3", { children: "Versions" }),
+          /* @__PURE__ */ jsx2("ul", { children: loaded.detail.versions.map((version) => /* @__PURE__ */ jsxs("li", { children: [
+            "Revision ",
+            version.revision,
+            " \xB7 ",
+            version.createdAt,
+            version.id === site.currentVersion?.id ? " \xB7 current" : ""
+          ] }, version.id)) }),
+          loaded.detail.versionsTruncated && /* @__PURE__ */ jsx2("p", { children: "Older versions are not included in this response." }),
+          canPublish && site.currentVersion && /* @__PURE__ */ jsxs("fieldset", { disabled: busy, children: [
+            /* @__PURE__ */ jsx2("legend", { children: "Manage Site" }),
+            /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => setConfirmation("status"), children: site.status === "active" ? "Archive Site" : "Restore Site" }),
+            /* @__PURE__ */ jsxs("label", { children: [
+              "Version to restore",
+              /* @__PURE__ */ jsxs(
+                "select",
+                {
+                  value: rollbackId,
+                  onChange: (event) => {
+                    setRollbackId(event.target.value);
+                    setConfirmation(null);
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx2("option", { value: "", children: "Choose a version" }),
+                    loaded.detail.versions.filter((version) => version.id !== site.currentVersion?.id).map((version) => /* @__PURE__ */ jsxs("option", { value: version.id, children: [
+                      "Revision ",
+                      version.revision
+                    ] }, version.id))
+                  ]
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx2(
+              "button",
+              {
+                type: "button",
+                disabled: !rollbackId,
+                onClick: () => setConfirmation("rollback"),
+                children: "Review rollback"
+              }
+            ),
+            confirmation && /* @__PURE__ */ jsxs("div", { role: "group", "aria-label": "Confirm Site change", children: [
+              /* @__PURE__ */ jsx2("p", { children: confirmation === "rollback" ? "Make the selected version current?" : site.status === "active" ? "Archive this Site for workspace users?" : "Restore this Site for workspace users?" }),
+              /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => void commit(), children: "Confirm change" }),
+              /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => setConfirmation(null), children: "Keep current state" })
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx2("button", { type: "button", disabled: busy, onClick: () => setReload((value) => value + 1), children: "Refresh Site" })
+      ]
+    }
+  );
+}
+
+export {
+  PUBLISHED_HTML_ARTIFACT_IFRAME_SANDBOX,
+  publishedHtmlArtifactDocument,
+  PublishedHtmlArtifactFrame,
+  openGeniSiteBridgePortFromBootstrap,
+  loadSiteSnapshot,
+  SiteList,
+  SiteDetail
+};
+//# sourceMappingURL=chunk-SCOTPE2I.js.map