@sanity/cross-dataset-duplicator 1.4.1 → 1.5.0

package/dist/index.mjs

@@ -0,0 +1,654 @@
+import { useClient, useSchema, useWorkspaces, Preview, definePlugin } from "sanity";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import React, { useState, useEffect, useCallback, createContext, useContext } from "react";
+import { InfoOutlineIcon, ArrowRightIcon, SearchIcon, LaunchIcon } from "@sanity/icons";
+import { useSecrets, SettingsView } from "@sanity/studio-secrets";
+import { Card, Flex, Button, Badge, Tooltip, Box, Text, useTheme, Container, Stack, Label, Select, Checkbox, Spinner, Grid, TextInput } from "@sanity/ui";
+import mapLimit from "async/mapLimit";
+import asyncify from "async/asyncify";
+import { extractWithPath } from "@sanity/mutator";
+import { dset } from "dset";
+import { isAssetId, isSanityFileAsset } from "@sanity/asset-utils";
+function createInitialMessage(docCount = 0, refsCount = 0) {
+  return [
+    docCount === 1 ? "This Document contains" : `These ${docCount} Documents contain`,
+    refsCount === 1 ? "1 Reference." : `${refsCount} References.`,
+    refsCount === 1 ? "That Document" : "Those Documents",
+    "may have References too. If referenced Documents do not exist at the target Destination, this transaction will fail."
+  ].join(" ");
+}
+const stickyStyles = (isDarkMode = !0) => ({
+  position: "sticky",
+  top: 0,
+  zIndex: 100,
+  backgroundColor: isDarkMode ? "rgba(10,10,10,0.95)" : "rgba(255,255,255,0.95)"
+});
+async function getDocumentsInArray(options) {
+  const { fetchIds, client, pluginConfig, currentIds, projection } = options, collection = [], query = `*[${["_id in $fetchIds", pluginConfig.filter].filter(Boolean).join(" && ")}]${projection ?? ""}`, data = await client.fetch(query, {
+    fetchIds: fetchIds ?? []
+  });
+  if (!data?.length)
+    return [];
+  const localCurrentIds = currentIds ?? /* @__PURE__ */ new Set(), newDataIds = new Set(
+    data.map((dataDoc) => dataDoc._id).filter((id) => currentIds?.size ? !localCurrentIds.has(id) : !!id)
+  );
+  return newDataIds.size && (collection.push(...data), localCurrentIds.add(...newDataIds), await Promise.all(
+    data.map(async (doc) => {
+      const references = extractWithPath(".._ref", doc).map((ref) => ref.value);
+      if (references.length) {
+        const newReferenceIds = new Set(
+          references.filter((ref) => !localCurrentIds.has(ref))
+        );
+        if (newReferenceIds.size) {
+          const referenceDocs = await getDocumentsInArray({
+            fetchIds: Array.from(newReferenceIds),
+            currentIds: localCurrentIds,
+            client,
+            pluginConfig
+          });
+          referenceDocs?.length && collection.push(...referenceDocs);
+        }
+      }
+    })
+  )), collection.filter(Boolean).reduce((acc, cur) => acc.some((doc) => doc._id === cur._id) ? acc : [...acc, cur], []);
+}
+const buttons = ["All", "None", null, "New", "Existing", "Older", null, "Documents", "Assets"];
+function SelectButtons(props) {
+  const { payload, setPayload } = props, [disabledActions, setDisabledActions] = useState([]);
+  useEffect(() => {
+    !disabledActions?.length && payload.every((item) => item.include) && setDisabledActions(["ALL"]);
+  }, [disabledActions?.length, payload]);
+  function handleSelectButton(action) {
+    if (!action || !payload.length) return;
+    const newPayload = [...payload];
+    switch (action) {
+      case "ALL":
+        newPayload.map((item) => item.include = !0);
+        break;
+      case "NONE":
+        newPayload.map((item) => item.include = !1);
+        break;
+      case "NEW":
+        newPayload.map((item) => item.include = item.status === "CREATE");
+        break;
+      case "EXISTING":
+        newPayload.map((item) => item.include = item.status === "EXISTS");
+        break;
+      case "OLDER":
+        newPayload.map((item) => item.include = item.status === "OVERWRITE");
+        break;
+      case "ASSETS":
+        newPayload.map((item) => item.include = isAssetId(item.doc._id));
+        break;
+      case "DOCUMENTS":
+        newPayload.map((item) => item.include = !isAssetId(item.doc._id));
+        break;
+    }
+    setDisabledActions([action]), setPayload(newPayload);
+  }
+  return /* @__PURE__ */ jsx(Card, { padding: 1, radius: 3, shadow: 1, children: /* @__PURE__ */ jsx(Flex, { gap: 2, wrap: "wrap", children: buttons.map(
+    (action, actionIndex) => action ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        fontSize: 1,
+        mode: "bleed",
+        padding: 2,
+        text: action,
+        disabled: disabledActions.includes(action.toUpperCase()),
+        onClick: () => handleSelectButton(action.toUpperCase())
+      },
+      action
+    ) : (
+      // eslint-disable-next-line react/no-array-index-key
+      /* @__PURE__ */ jsx(Card, { borderLeft: !0 }, `divider-${actionIndex}`)
+    )
+  ) }) });
+}
+const documentTones = {
+  EXISTS: "primary",
+  OVERWRITE: "critical",
+  UPDATE: "caution",
+  CREATE: "positive",
+  UNPUBLISHED: "caution"
+}, assetTones = {
+  EXISTS: "critical",
+  OVERWRITE: "critical",
+  UPDATE: "critical",
+  CREATE: "positive",
+  UNPUBLISHED: "default"
+}, documentMessages = {
+  // Only happens once document is copied the first time, and _updatedAt is the same
+  EXISTS: "This document already exists at the Destination with the same ID with the same Updated time.",
+  // Is true immediately after transaction as _updatedAt is updated by API after mutation
+  // Is also true if the document at the destination has been manually modified
+  // Presently, the plugin doesn't actually compare the two documents
+  OVERWRITE: "A newer version of this document exists at the Destination, and it will be overwritten with this version.",
+  // Document at destination is older
+  UPDATE: "An older version of this document exists at the Destination, and it will be overwritten with this version.",
+  // Document at destination doesn't exist
+  CREATE: "This document will be created at the destination.",
+  UNPUBLISHED: "A Draft version of this Document exists in this Dataset, but only the Published version will be duplicated to the destination."
+}, assetMessages = {
+  EXISTS: "This Asset already exists at the Destination",
+  OVERWRITE: "This Asset already exists at the Destination",
+  UPDATE: "This Asset already exists at the Destination",
+  CREATE: "This Asset does not yet exist at the Destination",
+  UNPUBLISHED: ""
+}, assetStatus = {
+  EXISTS: "RE-UPLOAD",
+  OVERWRITE: "RE-UPLOAD",
+  UPDATE: "RE-UPLOAD",
+  CREATE: "UPLOAD",
+  UNPUBLISHED: ""
+};
+function StatusBadge(props) {
+  const { status, isAsset } = props;
+  if (!status)
+    return null;
+  const badgeTone = isAsset ? assetTones[status] : documentTones[status];
+  if (!badgeTone)
+    return /* @__PURE__ */ jsx(Badge, { muted: !0, padding: 2, fontSize: 1, mode: "outline", children: "Checking..." });
+  const badgeText = isAsset ? assetMessages[status] : documentMessages[status], badgeStatus = isAsset ? assetStatus[status] : status;
+  return /* @__PURE__ */ jsx(
+    Tooltip,
+    {
+      content: /* @__PURE__ */ jsx(Box, { padding: 3, style: { maxWidth: 200 }, children: /* @__PURE__ */ jsx(Text, { size: 1, children: badgeText }) }),
+      fallbackPlacements: ["right", "left"],
+      placement: "top",
+      portal: !0,
+      children: /* @__PURE__ */ jsxs(Badge, { muted: !0, padding: 3, fontSize: 1, tone: badgeTone, mode: "outline", children: [
+        badgeStatus,
+        /* @__PURE__ */ jsx(Box, { marginLeft: 2, display: "inline-block", as: "span", children: /* @__PURE__ */ jsx(InfoOutlineIcon, {}) })
+      ] })
+    }
+  );
+}
+function Feedback(props) {
+  const { children, tone = "caution" } = props;
+  return /* @__PURE__ */ jsx(Card, { padding: 3, radius: 2, shadow: 1, tone, children: /* @__PURE__ */ jsx(Text, { size: 1, children }) });
+}
+function Duplicator(props) {
+  const { docs, token, pluginConfig, onDuplicated } = props, isDarkMode = useTheme().sanity.color.dark, originClient = useClient({ apiVersion: pluginConfig.apiVersion }), schema = useSchema(), workspaces = useWorkspaces(), workspacesOptions = workspaces.map((workspace) => ({
+    ...workspace,
+    disabled: workspace.dataset === originClient.config().dataset && workspace.projectId === originClient.config().projectId
+  })), [destination, setDestination] = useState(
+    workspaces.length ? workspacesOptions.find((space) => !space.disabled) ?? null : null
+  ), [message, setMessage] = useState(null), [payload, setPayload] = useState([]), [hasReferences, setHasReferences] = useState(!1), [isDuplicating, setIsDuplicating] = useState(!1), [isGathering, setIsGathering] = useState(!1), [progress, setProgress] = useState([0, 0]);
+  useEffect(() => {
+    const expr = ".._ref", initialRefs = [], initialPayload = [];
+    docs.forEach((doc) => {
+      const refs = extractWithPath(expr, doc).map((ref) => ref.value);
+      initialRefs.push(...refs), initialPayload.push({ include: !0, doc });
+    }), updatePayloadStatuses(initialPayload);
+    const docCount = docs.length, refsCount = initialRefs.length;
+    initialRefs.length && (setHasReferences(!0), setMessage({
+      tone: "caution",
+      text: createInitialMessage(docCount, refsCount)
+    }));
+  }, [docs]), useEffect(() => {
+    updatePayloadStatuses();
+  }, [destination]);
+  async function updatePayloadStatuses(newPayload = []) {
+    const payloadActual = newPayload.length ? newPayload : payload;
+    if (!payloadActual.length || !destination?.name)
+      return;
+    const payloadIds = payloadActual.map(({ doc }) => doc._id), destinationData = await originClient.withConfig({
+      dataset: destination.dataset,
+      projectId: destination.projectId
+    }).fetch(
+      "*[_id in $payloadIds]{ _id, _updatedAt }",
+      { payloadIds }
+    ), updatedPayload = payloadActual.map((item) => {
+      const existingDoc = destinationData.find((doc) => doc._id === item.doc._id);
+      return existingDoc?._updatedAt && item?.doc?._updatedAt ? existingDoc._updatedAt === item.doc._updatedAt ? item.status = "EXISTS" : existingDoc._updatedAt && item.doc._updatedAt && (item.status = new Date(existingDoc._updatedAt) > new Date(item.doc._updatedAt) ? (
+        // Document at destination is newer
+        "OVERWRITE"
+      ) : (
+        // Document at destination is older
+        "UPDATE"
+      )) : item.status = "CREATE", item;
+    });
+    setPayload(updatedPayload);
+  }
+  function handleCheckbox(_id) {
+    const updatedPayload = payload.map((item) => (item.doc._id === _id && (item.include = !item.include), item));
+    setPayload(updatedPayload);
+  }
+  async function handleReferences() {
+    setIsGathering(!0);
+    const docIds = docs.map((doc) => doc._id), payloadDocs = await getDocumentsInArray({
+      fetchIds: docIds,
+      client: originClient,
+      pluginConfig
+    }), draftDocs = await getDocumentsInArray({
+      fetchIds: docIds.map((id) => `drafts.${id}`),
+      client: originClient,
+      projection: "{_id}",
+      pluginConfig
+    }), draftDocsIds = new Set(draftDocs.map(({ _id }) => _id)), payloadShaped = payloadDocs.map((doc) => ({
+      doc,
+      // Include this in the transaction?
+      include: !0,
+      // Does it exist at the destination?
+      status: void 0,
+      // Does it have any drafts?
+      hasDraft: draftDocsIds.has(`drafts.${doc._id}`)
+    }));
+    setPayload(payloadShaped), updatePayloadStatuses(payloadShaped), setIsGathering(!1);
+  }
+  async function handleDuplicate() {
+    if (!destination)
+      return;
+    setIsDuplicating(!0);
+    const assetsCount = payload.filter(({ doc, include }) => include && isAssetId(doc._id)).length;
+    let currentProgress = 0;
+    setProgress([currentProgress, assetsCount]), setMessage({ text: "Duplicating...", tone: "transparent" });
+    const destinationClient = originClient.withConfig({
+      apiVersion: pluginConfig.apiVersion,
+      dataset: destination.dataset,
+      projectId: destination.projectId
+    }), transactionDocs = [], svgMaps = [];
+    async function fetchDoc(doc) {
+      if (isAssetId(doc._id)) {
+        const typeIsFile = isSanityFileAsset(doc), downloadUrl = typeIsFile ? doc.url : `${doc.url}?dlRaw=true`, downloadConfig = typeIsFile ? {} : { headers: { Authorization: `Bearer ${token}` } };
+        await fetch(downloadUrl, downloadConfig).then(async (res) => {
+          const assetData = await res.blob(), options = { filename: doc.originalFilename }, assetDoc = await destinationClient.assets.upload(
+            typeIsFile ? "file" : "image",
+            assetData,
+            options
+          );
+          doc?.extension === "svg" && svgMaps.push({ old: doc._id, new: assetDoc._id }), transactionDocs.push(assetDoc), doc.url = assetDoc.url, doc.path = assetDoc.path;
+        }), currentProgress += 1, setMessage({
+          text: `Duplicating ${currentProgress}/${assetsCount} Assets`,
+          tone: "default"
+        }), setProgress([currentProgress, assetsCount]);
+      }
+      return transactionDocs.push(doc);
+    }
+    await new Promise((resolve, reject) => {
+      const payloadIncludedDocs = payload.filter((item) => item.include).map((item) => item.doc);
+      mapLimit(payloadIncludedDocs, 3, asyncify(fetchDoc), (err) => {
+        err && (setIsDuplicating(!1), setMessage({ tone: "critical", text: "Duplication Failed" }), console.error(err), reject(new Error("Duplication Failed"))), resolve();
+      });
+    });
+    const transactionDocsMapped = transactionDocs.map((doc) => {
+      const references = extractWithPath(".._ref", doc);
+      return references.length && references.forEach((ref) => {
+        const newRefValue = svgMaps.find((asset) => asset.old === ref.value)?.new;
+        if (newRefValue) {
+          const refPath = ref.path.join(".");
+          dset(doc, refPath, newRefValue);
+        }
+      }), doc;
+    }), transaction = destinationClient.transaction();
+    if (transactionDocsMapped.forEach((doc) => {
+      transaction.createOrReplace(doc);
+    }), await transaction.commit().then((res) => {
+      setMessage({ tone: "positive", text: "Duplication complete!" }), updatePayloadStatuses();
+    }).catch((err) => {
+      setMessage({ tone: "critical", text: err.details.description });
+    }), setIsDuplicating(!1), setProgress([0, 0]), onDuplicated)
+      try {
+        await onDuplicated();
+      } catch (error) {
+        setMessage({ tone: "critical", text: `Error in onDuplicated hook: ${error}` });
+      }
+  }
+  function handleChange(e) {
+    if (!workspacesOptions.length)
+      return;
+    const targeted = workspacesOptions.find((space) => space.name === e.currentTarget.value);
+    targeted && setDestination(targeted);
+  }
+  const payloadCount = payload.length, firstSvgIndex = payload.findIndex(({ doc }) => doc.extension === "svg"), selectedDocumentsCount = payload.filter(
+    (item) => item.include && !isAssetId(item.doc._id)
+  ).length, selectedAssetsCount = payload.filter(
+    (item) => item.include && isAssetId(item.doc._id)
+  ).length, selectedTotal = selectedDocumentsCount + selectedAssetsCount, destinationTitle = destination?.title ?? destination?.name, hasMultipleProjectIds = new Set(workspacesOptions.map((space) => space?.projectId).filter(Boolean)).size > 1, headingText = [selectedTotal, "/", payloadCount, "Documents and Assets selected"].join(" "), buttonText = React.useMemo(() => {
+    const text = ["Duplicate"];
+    return selectedDocumentsCount > 1 && text.push(
+      String(selectedDocumentsCount),
+      selectedDocumentsCount === 1 ? "Document" : "Documents"
+    ), selectedAssetsCount > 1 && text.push("and", String(selectedAssetsCount), selectedAssetsCount === 1 ? "Asset" : "Assets"), originClient.config().projectId !== destination?.projectId && text.push("between Projects"), text.push("to", String(destinationTitle)), text.join(" ");
+  }, [
+    selectedDocumentsCount,
+    selectedAssetsCount,
+    originClient,
+    destination?.projectId,
+    destinationTitle
+  ]);
+  return workspacesOptions.length < 2 ? /* @__PURE__ */ jsxs(Feedback, { tone: "critical", children: [
+    /* @__PURE__ */ jsx("code", { children: "sanity.config.ts" }),
+    " must contain at least two Workspaces to use this plugin."
+  ] }) : /* @__PURE__ */ jsx(Container, { width: 1, children: /* @__PURE__ */ jsx(Card, { border: !0, children: /* @__PURE__ */ jsxs(Stack, { children: [
+    /* @__PURE__ */ jsx(Card, { padding: 4, style: stickyStyles(isDarkMode), children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+      /* @__PURE__ */ jsxs(Flex, { gap: 3, children: [
+        /* @__PURE__ */ jsxs(Stack, { style: { flex: 1 }, space: 3, children: [
+          /* @__PURE__ */ jsx(Label, { children: "Duplicate from" }),
+          /* @__PURE__ */ jsx(Select, { readOnly: !0, value: workspacesOptions.find((space) => space.disabled)?.name, children: workspacesOptions.filter((space) => space.disabled).map((space) => /* @__PURE__ */ jsxs("option", { value: space.name, disabled: space.disabled, children: [
+            space.title ?? space.name,
+            hasMultipleProjectIds ? ` (${space.projectId})` : ""
+          ] }, space.name)) })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { padding: 4, paddingTop: 5, paddingBottom: 0, children: /* @__PURE__ */ jsx(Text, { size: 3, children: /* @__PURE__ */ jsx(ArrowRightIcon, {}) }) }),
+        /* @__PURE__ */ jsxs(Stack, { style: { flex: 1 }, space: 3, children: [
+          /* @__PURE__ */ jsx(Label, { children: "To Destination" }),
+          /* @__PURE__ */ jsx(Select, { onChange: handleChange, children: workspacesOptions.map((space) => /* @__PURE__ */ jsxs("option", { value: space.name, disabled: space.disabled, children: [
+            space.title ?? space.name,
+            hasMultipleProjectIds ? ` (${space.projectId})` : "",
+            space.disabled ? " (Current)" : ""
+          ] }, space.name)) })
+        ] })
+      ] }),
+      isDuplicating && /* @__PURE__ */ jsx(Card, { border: !0, radius: 2, children: /* @__PURE__ */ jsx(
+        Card,
+        {
+          style: {
+            width: "100%",
+            transform: `scaleX(${progress[0] / progress[1]})`,
+            transformOrigin: "left",
+            transition: "transform .2s ease",
+            boxSizing: "border-box"
+          },
+          padding: 1,
+          tone: "positive"
+        }
+      ) }),
+      payload.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Label, { children: headingText }),
+        /* @__PURE__ */ jsx(SelectButtons, { payload, setPayload })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsx(Card, { borderTop: !0, padding: 4, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      message && /* @__PURE__ */ jsx(Card, { padding: 3, radius: 2, shadow: 1, tone: message.tone, children: /* @__PURE__ */ jsx(Text, { size: 1, children: message.text }) }),
+      payload.length > 0 ? /* @__PURE__ */ jsx(Stack, { children: payload.map(({ doc, include, status, hasDraft }, index) => {
+        const schemaType = schema.get(doc._type);
+        return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+          /* @__PURE__ */ jsxs(Flex, { align: "center", children: [
+            /* @__PURE__ */ jsx(Checkbox, { checked: include, onChange: () => handleCheckbox(doc._id) }),
+            /* @__PURE__ */ jsx(Box, { flex: 1, paddingX: 3, children: schemaType ? /* @__PURE__ */ jsx(Preview, { value: doc, schemaType }) : /* @__PURE__ */ jsx(Card, { tone: "caution", children: "Invalid schema type" }) }),
+            /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+              hasDraft ? /* @__PURE__ */ jsx(StatusBadge, { status: "UNPUBLISHED", isAsset: !1 }) : null,
+              /* @__PURE__ */ jsx(StatusBadge, { status, isAsset: isAssetId(doc._id) })
+            ] })
+          ] }),
+          doc?.extension === "svg" && index === firstSvgIndex && /* @__PURE__ */ jsx(Card, { padding: 3, radius: 2, shadow: 1, tone: "caution", children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
+            "Due to how SVGs are sanitized after first uploaded, duplicated SVG assets may have new ",
+            /* @__PURE__ */ jsx("code", { children: "_id" }),
+            "'s at the destination. The newly generated ",
+            /* @__PURE__ */ jsx("code", { children: "_id" }),
+            " will be the same in each duplication, but it will never be the same ",
+            /* @__PURE__ */ jsx("code", { children: "_id" }),
+            " as the first time this Asset was uploaded. References to the asset will be updated to use the new ",
+            /* @__PURE__ */ jsx("code", { children: "_id" }),
+            "."
+          ] }) })
+        ] }, doc._id);
+      }) }) : /* @__PURE__ */ jsx(Flex, { padding: 4, align: "center", justify: "center", children: /* @__PURE__ */ jsx(Spinner, {}) }),
+      /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+        hasReferences && /* @__PURE__ */ jsx(
+          Button,
+          {
+            fontSize: 2,
+            padding: 4,
+            tone: "positive",
+            mode: "ghost",
+            icon: SearchIcon,
+            onClick: handleReferences,
+            text: "Gather References",
+            disabled: isDuplicating || !selectedTotal || isGathering
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            fontSize: 2,
+            padding: 4,
+            tone: "positive",
+            icon: LaunchIcon,
+            onClick: handleDuplicate,
+            text: buttonText,
+            disabled: isDuplicating || !selectedTotal || isGathering
+          }
+        )
+      ] })
+    ] }) })
+  ] }) }) });
+}
+function DuplicatorQuery(props) {
+  const { token, pluginConfig } = props, { queries: preDefinedQueries, apiVersion } = pluginConfig, originClient = useClient({ apiVersion }), schemaTypes = useSchema().getTypeNames(), [value, setValue] = useState(""), [fetched, setFetched] = useState(!1), [initialData, setInitialData] = useState({
+    docs: []
+  });
+  function handleSubmit(e) {
+    e && e.preventDefault(), originClient.fetch(value).then((res) => {
+      const registeredAndPublishedDocs = res.length ? res.filter((doc) => schemaTypes.includes(doc._type)).filter((doc) => !doc._id.startsWith("drafts.")) : [];
+      setInitialData({
+        docs: registeredAndPublishedDocs
+      }), setFetched(!0);
+    }).catch((err) => console.error(err));
+  }
+  return useEffect(() => {
+    !initialData.docs?.length && value && handleSubmit();
+  }, []), /* @__PURE__ */ jsx(Card, { padding: [0, 0, 0, 5], children: /* @__PURE__ */ jsx(Container, { children: /* @__PURE__ */ jsxs(Grid, { columns: [1, 1, 1, 2], gap: [1, 1, 1, 4], children: [
+    /* @__PURE__ */ jsxs(Box, { padding: [2, 2, 2, 0], children: [
+      /* @__PURE__ */ jsx(Card, { padding: 4, radius: 3, border: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Label, { children: "Initial Documents Query" }) }),
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { children: "Start with a valid GROQ query to load initial documents. The query will need to return an Array of Objects. Drafts will be removed from the results." }) }),
+        /* @__PURE__ */ jsx("form", { onSubmit: handleSubmit, children: /* @__PURE__ */ jsxs(Flex, { children: [
+          /* @__PURE__ */ jsx(Box, { flex: 1, paddingRight: 2, children: /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              style: { fontFamily: "monospace" },
+              fontSize: 2,
+              onChange: (event) => setValue(event.currentTarget.value),
+              padding: 4,
+              placeholder: '*[_type == "article"]',
+              value: value ?? ""
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              padding: 2,
+              paddingX: 4,
+              tone: "primary",
+              onClick: handleSubmit,
+              text: "Query",
+              disabled: !value
+            }
+          )
+        ] }) })
+      ] }) }),
+      preDefinedQueries && preDefinedQueries?.length > 0 && /* @__PURE__ */ jsx(Card, { marginTop: 2, padding: 4, radius: 3, border: !0, children: /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Stack, { space: 4, children: [
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Label, { children: "Predefined Queries" }) }),
+        /* @__PURE__ */ jsx(Stack, { space: 2, children: preDefinedQueries.map((query) => /* @__PURE__ */ jsx(
+          Button,
+          {
+            padding: 2,
+            paddingX: 4,
+            tone: "primary",
+            onClick: () => setValue(`*[${query.query}]`),
+            text: query.label
+          },
+          query.label.replace(/\s+/g, "-")
+        )) })
+      ] }) }) })
+    ] }),
+    fetched && initialData.docs.length < 1 && /* @__PURE__ */ jsx(Container, { width: 1, children: /* @__PURE__ */ jsx(Card, { padding: 5, children: value ? "No documents match this query" : "Start with a valid GROQ query" }) }),
+    initialData.docs?.length > 0 && /* @__PURE__ */ jsx(
+      Duplicator,
+      {
+        docs: initialData.docs,
+        token,
+        pluginConfig
+      }
+    )
+  ] }) }) });
+}
+function DuplicatorWrapper(props) {
+  const { docs, token, pluginConfig, onDuplicated } = props, [inbound, setInbound] = useState([]), { follow = [], apiVersion } = pluginConfig, [mode, setMode] = useState(
+    follow.length === 1 ? follow[0] : "outbound"
+  ), client = useClient({ apiVersion });
+  return useEffect(() => {
+    (async () => {
+      if (follow.includes("inbound")) {
+        const inboundReferences = await client.fetch("*[references($id)]", { id: docs[0]._id });
+        setInbound([...props.docs, ...inboundReferences]);
+      }
+    })();
+  }, []), /* @__PURE__ */ jsxs(Container, { children: [
+    follow.length > 1 && (follow.includes("inbound") || follow.includes("outbound")) ? /* @__PURE__ */ jsx(Card, { paddingX: 4, paddingBottom: 4, marginBottom: 4, borderBottom: !0, children: /* @__PURE__ */ jsxs(Grid, { columns: 2, gap: 4, children: [
+      follow.includes("outbound") ? /* @__PURE__ */ jsx(
+        Button,
+        {
+          mode: "ghost",
+          tone: "primary",
+          selected: mode === "outbound",
+          onClick: () => setMode("outbound"),
+          text: "Outbound"
+        }
+      ) : null,
+      follow.includes("inbound") ? /* @__PURE__ */ jsx(
+        Button,
+        {
+          mode: "ghost",
+          tone: "primary",
+          selected: mode === "inbound",
+          onClick: () => setMode("inbound"),
+          disabled: inbound.length === 0,
+          text: inbound.length > 0 ? `Inbound (${inbound.length})` : "No inbound references"
+        }
+      ) : null
+    ] }) }) : null,
+    /* @__PURE__ */ jsx(
+      Duplicator,
+      {
+        docs: mode === "outbound" ? docs : inbound,
+        token,
+        pluginConfig,
+        onDuplicated
+      }
+    )
+  ] });
+}
+const SECRET_NAMESPACE = "CrossDatasetDuplicator", DEFAULT_CONFIG = {
+  apiVersion: "2025-02-19",
+  tool: !0,
+  types: [],
+  filter: "",
+  follow: ["outbound"],
+  queries: []
+};
+function ResetSecret({ apiVersion }) {
+  const client = useClient({ apiVersion }), handleClick = useCallback(() => {
+    client.delete({ query: `*[_id == "secrets.${SECRET_NAMESPACE}"]` });
+  }, [client]);
+  return /* @__PURE__ */ jsx(Flex, { align: "center", justify: "flex-end", paddingX: [2, 2, 2, 5], paddingY: 5, children: /* @__PURE__ */ jsx(
+    Button,
+    {
+      text: "Reset Secret",
+      onClick: handleClick,
+      mode: "ghost",
+      tone: "critical",
+      fontSize: 1,
+      padding: 2
+    }
+  ) });
+}
+const CrossDatasetDuplicatorContext = createContext(DEFAULT_CONFIG);
+function useCrossDatasetDuplicatorConfig() {
+  return useContext(CrossDatasetDuplicatorContext);
+}
+function ConfigProvider(props) {
+  const { pluginConfig, ...rest } = props;
+  return /* @__PURE__ */ jsx(CrossDatasetDuplicatorContext.Provider, { value: pluginConfig, children: props.renderDefault(rest) });
+}
+const secretConfigKeys = [
+  {
+    key: "bearerToken",
+    title: "An API token with Viewer permissions is required to duplicate the original files of assets, and will be used for all Duplications. Create one at sanity.io/manage",
+    description: ""
+  }
+];
+function CrossDatasetDuplicator(props) {
+  const { mode = "tool", docs = [], onDuplicated } = props ?? {}, pluginConfig = useCrossDatasetDuplicatorConfig(), { loading, secrets } = useSecrets(SECRET_NAMESPACE), [showSecretsPrompt, setShowSecretsPrompt] = useState(!1);
+  return useEffect(() => {
+    secrets && setShowSecretsPrompt(!secrets?.bearerToken);
+  }, [secrets]), loading ? /* @__PURE__ */ jsx(Flex, { justify: "center", align: "center", children: /* @__PURE__ */ jsx(Box, { padding: 5, children: /* @__PURE__ */ jsx(Spinner, {}) }) }) : !loading && showSecretsPrompt || !secrets?.bearerToken ? /* @__PURE__ */ jsx(
+    SettingsView,
+    {
+      title: "Token Required",
+      namespace: SECRET_NAMESPACE,
+      keys: secretConfigKeys,
+      onClose: () => setShowSecretsPrompt(!1)
+    }
+  ) : mode === "tool" && pluginConfig ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(DuplicatorQuery, { token: secrets?.bearerToken, pluginConfig }),
+    /* @__PURE__ */ jsx(ResetSecret, { apiVersion: pluginConfig.apiVersion })
+  ] }) : docs?.length ? pluginConfig ? /* @__PURE__ */ jsx(
+    DuplicatorWrapper,
+    {
+      docs,
+      token: secrets?.bearerToken,
+      pluginConfig,
+      onDuplicated
+    }
+  ) : /* @__PURE__ */ jsx(Feedback, { children: "No plugin config" }) : /* @__PURE__ */ jsx(Feedback, { children: "No docs passed into Duplicator Tool" });
+}
+function CrossDatasetDuplicatorAction(props) {
+  const { docs = [], onDuplicated } = props;
+  return /* @__PURE__ */ jsx(CrossDatasetDuplicator, { mode: "action", docs, onDuplicated });
+}
+const DuplicateToAction = (props) => {
+  const { draft, published, onComplete } = props, [dialogOpen, setDialogOpen] = useState(!1);
+  return {
+    disabled: draft,
+    title: draft ? "Document must be Published to begin" : null,
+    label: "Duplicate to...",
+    dialog: dialogOpen && published && {
+      type: "modal",
+      title: "Cross Dataset Duplicator",
+      content: /* @__PURE__ */ jsx(CrossDatasetDuplicatorAction, { docs: [published] }),
+      onClose: () => {
+        onComplete(), setDialogOpen(!1);
+      }
+    },
+    onHandle: () => setDialogOpen(!0),
+    icon: LaunchIcon
+  };
+};
+DuplicateToAction.action = "duplicateTo";
+function CrossDatasetDuplicatorTool(props) {
+  const { docs = [] } = props.tool.options ?? {};
+  return /* @__PURE__ */ jsx(CrossDatasetDuplicator, { mode: "tool", docs });
+}
+const crossDatasetDuplicatorTool = () => ({
+  title: "Duplicator",
+  name: "duplicator",
+  icon: LaunchIcon,
+  component: CrossDatasetDuplicatorTool,
+  options: {
+    docs: []
+  }
+}), crossDatasetDuplicator = definePlugin((config = {}) => {
+  const pluginConfig = { ...DEFAULT_CONFIG, ...config }, { types } = pluginConfig;
+  return {
+    name: "@sanity/cross-dataset-duplicator",
+    tools: (prev) => pluginConfig.tool ? [...prev, crossDatasetDuplicatorTool()] : prev,
+    studio: {
+      components: {
+        layout: (props) => ConfigProvider({ ...props, pluginConfig })
+      }
+    },
+    document: {
+      actions: (prev, { schemaType }) => types && types.includes(schemaType) ? [...prev, DuplicateToAction] : prev
+    }
+  };
+});
+export {
+  CrossDatasetDuplicatorAction,
+  DuplicateToAction,
+  crossDatasetDuplicator,
+  useCrossDatasetDuplicatorConfig
+};
+//# sourceMappingURL=index.mjs.map