strapi-plugin-dynamic-zone-tools 1.0.0

package/dist/admin/index.mjs

@@ -0,0 +1,2159 @@
+import React, { useRef, useEffect, useState } from "react";
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import { Flex, Dialog, Box, Typography, Alert, SingleSelect, SingleSelectOption, Button, Checkbox } from "@strapi/design-system";
+import { useFetchClient, useForm, useNotification, useQueryParams, unstable_useContentManagerContext } from "@strapi/strapi/admin";
+import { useIntl } from "react-intl";
+import { Duplicate, WarningCircle } from "@strapi/icons";
+import { generateKeyBetween, generateNKeysBetween } from "fractional-indexing";
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "dynamic-zone-tools";
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef(setPlugin);
+  useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const TRANSIENT_ENTRY_KEYS = /* @__PURE__ */ new Set(["id", "documentId", "__temp_key__"]);
+const ENTRY_LABEL_KEYS = ["title", "heading", "name", "label", "displayName", "question", "slug"];
+function getDynamicZoneEntryLabel(entry) {
+  if (!entry || typeof entry !== "object") {
+    return "";
+  }
+  for (const key of ENTRY_LABEL_KEYS) {
+    const value = entry[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  const componentUid = entry.__component;
+  if (typeof componentUid === "string") {
+    const shortName = componentUid.split(".").pop() || componentUid;
+    return shortName;
+  }
+  return "";
+}
+function getComponentDisplayName(componentUid) {
+  return componentUid.split(".").pop() || componentUid;
+}
+function filterAllowedDynamicZoneEntries(entries, allowedComponents) {
+  if (!Array.isArray(entries)) {
+    return { allowed: [], skippedCount: 0 };
+  }
+  if (!Array.isArray(allowedComponents)) {
+    return { allowed: entries, skippedCount: 0 };
+  }
+  const allowed = entries.filter((entry) => allowedComponents.includes(entry?.__component));
+  return { allowed, skippedCount: entries.length - allowed.length };
+}
+async function loadComponentSchemas(get) {
+  const response = await get("/content-manager/init");
+  const payload = response?.data?.data ?? response?.data ?? {};
+  const map = {};
+  (payload.components ?? []).forEach((component) => {
+    map[component.uid] = component.attributes ?? component.schema?.attributes ?? {};
+  });
+  return map;
+}
+function prepareZoneData(entries, schemas, insertOptions) {
+  const buildConnectItems = (value, attribute) => {
+    const items = (Array.isArray(value) ? value : [value]).filter(
+      (rel) => rel && typeof rel === "object" && rel.documentId
+    );
+    const keys2 = generateNKeysBetween(void 0, void 0, items.length);
+    return items.map((rel, index2) => ({
+      id: rel.id,
+      apiData: {
+        id: rel.id,
+        documentId: rel.documentId,
+        locale: rel.locale ?? void 0,
+        isTemporary: true
+      },
+      status: rel.status ?? (rel.publishedAt ? "published" : "draft"),
+      label: rel.title ?? rel.name ?? rel.label ?? rel.documentId,
+      href: `../collection-types/${attribute.target}/${rel.documentId}${rel.locale ? `?plugins[i18n][locale]=${rel.locale}` : ""}`,
+      __temp_key__: keys2[index2]
+    }));
+  };
+  const transformComponent = (data, attributes) => {
+    const out = {};
+    Object.entries(data ?? {}).forEach(([key, value]) => {
+      if (key === "id") return;
+      if (key === "__component") {
+        out[key] = value;
+        return;
+      }
+      const attribute = attributes?.[key];
+      if (!attribute) return;
+      if (value === null || value === void 0) {
+        if (attribute.type === "boolean") out[key] = value;
+        return;
+      }
+      switch (attribute.type) {
+        case "component": {
+          const nestedAttributes = schemas[attribute.component] ?? {};
+          if (attribute.repeatable) {
+            const items = Array.isArray(value) ? value : [];
+            const keys2 = generateNKeysBetween(void 0, void 0, items.length);
+            out[key] = items.map((item, index2) => ({
+              ...transformComponent(item, nestedAttributes),
+              __temp_key__: keys2[index2]
+            }));
+          } else {
+            out[key] = transformComponent(value, nestedAttributes);
+          }
+          break;
+        }
+        case "relation": {
+          if (attribute.target) {
+            out[key] = { connect: buildConnectItems(value, attribute), disconnect: [] };
+          }
+          break;
+        }
+        default:
+          out[key] = value;
+      }
+    });
+    return out;
+  };
+  const { previousKey = null, nextKey = null } = insertOptions ?? {};
+  const keys = insertOptions !== void 0 ? generateNKeysBetween(previousKey ?? null, nextKey ?? null, entries.length) : generateNKeysBetween(void 0, void 0, entries.length);
+  return entries.map((entry, index2) => ({
+    ...transformComponent(entry, schemas[entry.__component] ?? {}),
+    __component: entry.__component,
+    __temp_key__: keys[index2]
+  }));
+}
+function prepareZoneDataForInsert(entries, schemas, insertOptions) {
+  return prepareZoneData(entries, schemas, insertOptions);
+}
+function clonePlainValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+const COLLECTION_TYPES = "collection-types";
+const SINGLE_TYPES = "single-types";
+const ONE_WAY_RELATIONS = /* @__PURE__ */ new Set([
+  "oneWay",
+  "oneToOne",
+  "manyToOne",
+  "oneToManyMorph",
+  "oneToOneMorph"
+]);
+function isPlainObject$1(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getRelationIdentity(relation) {
+  if (!isPlainObject$1(relation)) {
+    return null;
+  }
+  const documentId = relation.documentId ?? relation.apiData?.documentId;
+  const locale = relation.locale ?? relation.apiData?.locale ?? "";
+  const id = relation.id ?? relation.apiData?.id;
+  if (documentId) {
+    return `${documentId}::${locale}`;
+  }
+  if (id !== null && id !== void 0) {
+    return `id:${id}`;
+  }
+  return null;
+}
+function getRelationDisplayValue(relation) {
+  for (const key of ["label", "title", "name", "displayName", "question", "heading", "slug", "documentId", "id"]) {
+    const value = relation[key];
+    if (typeof value === "string" && value.trim()) {
+      return value;
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+  }
+  return "";
+}
+function getRelationCollectionType(targetModel, contentTypes) {
+  const targetSchema = contentTypes?.find((schema) => schema?.uid === targetModel);
+  return targetSchema?.kind === "singleType" ? SINGLE_TYPES : COLLECTION_TYPES;
+}
+function getRelationHref(targetModel, contentTypes, documentId, locale) {
+  if (!targetModel || !documentId) {
+    return void 0;
+  }
+  const collectionType = getRelationCollectionType(targetModel, contentTypes);
+  const basePath = collectionType === SINGLE_TYPES ? `../${SINGLE_TYPES}/${targetModel}` : `../${COLLECTION_TYPES}/${targetModel}/${documentId}`;
+  return locale ? `${basePath}?plugins[i18n][locale]=${locale}` : basePath;
+}
+function normalizeFetchedRelations(value) {
+  if (Array.isArray(value)) {
+    return value.filter(isPlainObject$1);
+  }
+  if (isPlainObject$1(value) && Array.isArray(value.results)) {
+    return value.results.filter(isPlainObject$1);
+  }
+  if (isPlainObject$1(value)) {
+    return [value];
+  }
+  return [];
+}
+function toRelationConnectEntry(relation, attribute, contentTypes, tempKey) {
+  const id = relation.id ?? relation.apiData?.id;
+  const documentId = relation.documentId ?? relation.apiData?.documentId;
+  const locale = relation.locale ?? relation.apiData?.locale ?? null;
+  const label = relation.label ?? getRelationDisplayValue(relation);
+  const href = relation.href ?? getRelationHref(attribute.target, contentTypes, documentId, locale);
+  if (id === void 0 && !documentId) {
+    return null;
+  }
+  const entry = {
+    id,
+    documentId,
+    locale,
+    href,
+    label: label || documentId || (id !== void 0 && id !== null ? String(id) : ""),
+    __temp_key__: tempKey,
+    apiData: {
+      id,
+      documentId,
+      locale,
+      isTemporary: true
+    }
+  };
+  if (relation.status !== void 0) {
+    entry.status = relation.status;
+  } else if (typeof relation.publishedAt === "string") {
+    entry.status = "published";
+  }
+  return entry;
+}
+async function sanitizeRelationValue(attribute, value, fieldName, sourceContext, contentTypes, fetchRelationItems, createTempKey) {
+  const currentConnect = Array.isArray(value?.connect) ? value.connect : [];
+  const currentDisconnect = Array.isArray(value?.disconnect) ? value.disconnect : [];
+  const fetchedRelations = fetchRelationItems && sourceContext?.model && sourceContext?.id ? await fetchRelationItems(sourceContext.model, sourceContext.id, fieldName) : [];
+  const connectedByIdentity = /* @__PURE__ */ new Map();
+  for (const relation of currentConnect) {
+    const entry = toRelationConnectEntry(relation, attribute, contentTypes, createTempKey());
+    const identity = getRelationIdentity(entry);
+    if (entry && identity) {
+      connectedByIdentity.set(identity, entry);
+    }
+  }
+  const disconnectedIdentities = new Set(
+    currentDisconnect.map(getRelationIdentity).filter(Boolean)
+  );
+  const effectiveRelations = [];
+  for (const relation of fetchedRelations) {
+    const entry = toRelationConnectEntry(relation, attribute, contentTypes, createTempKey());
+    const identity = getRelationIdentity(entry);
+    if (!entry || !identity || disconnectedIdentities.has(identity)) {
+      continue;
+    }
+    if (connectedByIdentity.has(identity)) {
+      effectiveRelations.push(connectedByIdentity.get(identity));
+      connectedByIdentity.delete(identity);
+      continue;
+    }
+    effectiveRelations.push(entry);
+  }
+  for (const relation of connectedByIdentity.values()) {
+    effectiveRelations.push(relation);
+  }
+  const connect = ONE_WAY_RELATIONS.has(attribute.relation) ? effectiveRelations.slice(-1) : effectiveRelations;
+  return {
+    connect,
+    disconnect: []
+  };
+}
+async function cloneComponentFields(data, componentUid, options, sourceContext) {
+  const { schemas, contentTypes, fetchRelationItems } = options;
+  const attributes = schemas[componentUid] ?? {};
+  const out = { __component: data.__component };
+  const tempKeys = generateNKeysBetween(void 0, void 0, Object.keys(data).length + 10);
+  let tempKeyIndex = 0;
+  const createTempKey = () => tempKeys[tempKeyIndex++] ?? generateKeyBetween(null, null);
+  const context = {
+    model: componentUid,
+    id: sourceContext?.id ?? data.id
+  };
+  for (const [key, rawValue] of Object.entries(data)) {
+    const value = rawValue;
+    if (TRANSIENT_ENTRY_KEYS.has(key) || key === "__component") {
+      continue;
+    }
+    const attribute = attributes[key];
+    if (!attribute) {
+      if (value !== void 0) {
+        out[key] = clonePlainValue(value);
+      }
+      continue;
+    }
+    if (value === null || value === void 0) {
+      if (attribute.type === "boolean") {
+        out[key] = value;
+      }
+      continue;
+    }
+    switch (attribute.type) {
+      case "component": {
+        if (attribute.repeatable) {
+          const items = Array.isArray(value) ? value : [];
+          const keys = generateNKeysBetween(void 0, void 0, items.length);
+          out[key] = await Promise.all(
+            items.map(async (item, index2) => ({
+              ...await cloneComponentFields(item, attribute.component, options, {
+                model: attribute.component,
+                id: item?.id
+              }),
+              __temp_key__: keys[index2]
+            }))
+          );
+        } else {
+          out[key] = await cloneComponentFields(value, attribute.component, options, {
+            model: attribute.component,
+            id: value?.id
+          });
+        }
+        break;
+      }
+      case "dynamiczone": {
+        if (!Array.isArray(value)) {
+          out[key] = [];
+          break;
+        }
+        const keys = generateNKeysBetween(void 0, void 0, value.length);
+        out[key] = await Promise.all(
+          value.map(async (item, index2) => ({
+            ...await cloneFormDynamicZoneEntry(item, options),
+            __temp_key__: keys[index2]
+          }))
+        );
+        break;
+      }
+      case "relation":
+        if (!attribute.target) {
+          out[key] = { connect: [], disconnect: [] };
+          break;
+        }
+        out[key] = await sanitizeRelationValue(
+          attribute,
+          value,
+          key,
+          context,
+          contentTypes,
+          fetchRelationItems,
+          createTempKey
+        );
+        break;
+      default:
+        out[key] = clonePlainValue(value);
+    }
+  }
+  return out;
+}
+async function cloneFormDynamicZoneEntry(entry, options) {
+  if (!entry || typeof entry.__component !== "string") {
+    return entry;
+  }
+  const cloned = await cloneComponentFields(entry, entry.__component, options, {
+    model: entry.__component,
+    id: entry.id
+  });
+  return cloned;
+}
+function createFetchRelationItems(get, relationQueryParams = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  return async (relationModel, relationId, fieldName) => {
+    if (!relationModel || relationId === void 0 || relationId === null || !fieldName) {
+      return [];
+    }
+    const cacheKey = JSON.stringify({ relationModel, relationId, fieldName, relationQueryParams });
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const request = (async () => {
+      let page = 1;
+      let totalPages = 1;
+      const relations = [];
+      while (page <= totalPages) {
+        const response = await get(
+          `/content-manager/relations/${relationModel}/${relationId}/${fieldName}`,
+          {
+            params: {
+              ...relationQueryParams,
+              page,
+              pageSize: 100
+            }
+          }
+        );
+        const payload = response?.data ?? {};
+        const pageResults = normalizeFetchedRelations(payload.results).reverse();
+        relations.push(...pageResults);
+        const pagination = payload?.pagination;
+        const pageCount = typeof pagination?.pageCount === "number" ? pagination.pageCount : Math.max(1, Math.ceil((pagination?.total ?? pageResults.length) / 100));
+        totalPages = pageCount;
+        page += 1;
+      }
+      return relations;
+    })();
+    cache.set(cacheKey, request);
+    try {
+      return await request;
+    } catch {
+      cache.delete(cacheKey);
+      throw new Error("Failed to fetch relations");
+    }
+  };
+}
+function prepareEntryForZoneInsert(zone, targetIndex, entry) {
+  const prevKey = targetIndex > 0 ? zone[targetIndex - 1]?.__temp_key__ ?? null : null;
+  const nextKey = targetIndex < zone.length ? zone[targetIndex]?.__temp_key__ ?? null : null;
+  const { id, documentId, __temp_key__, ...rest } = entry;
+  return {
+    ...rest,
+    __temp_key__: generateKeyBetween(prevKey, nextKey)
+  };
+}
+const INDEX_SEGMENT = /^\d+$/;
+function getDynamicZoneFields(attributes) {
+  if (!attributes) {
+    return [];
+  }
+  return Object.entries(attributes).filter(([, attribute]) => attribute?.type === "dynamiczone").map(([fieldName, attribute]) => ({
+    fieldName,
+    displayName: attribute?.displayName || fieldName
+  }));
+}
+function getDynamicZonePathsFromValues(values) {
+  return Object.entries(values).filter(([, zone]) => Array.isArray(zone) && zone.some(isDynamicZoneEntry)).map(([fieldName]) => fieldName);
+}
+function isDynamicZoneEntry(value) {
+  return Boolean(value && typeof value === "object" && typeof value.__component === "string");
+}
+function getValueAtPath(source, path) {
+  if (!path) {
+    return source;
+  }
+  let current = source;
+  for (const segment of path.split(".")) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (INDEX_SEGMENT.test(segment)) {
+      if (!Array.isArray(current)) {
+        return void 0;
+      }
+      current = current[Number(segment)];
+      continue;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function findDynamicZoneLists(root = document) {
+  return Array.from(root.querySelectorAll("ol[aria-describedby]"));
+}
+function getDynamicZoneListItems(list) {
+  return Array.from(list.children).filter(
+    (child) => child instanceof HTMLLIElement
+  );
+}
+function findRowActionContainer(rowElement) {
+  const header = rowElement.querySelector("h3");
+  if (!header) {
+    return null;
+  }
+  for (const span of header.querySelectorAll("span")) {
+    const buttons = span.querySelectorAll(":scope > button");
+    if (buttons.length >= 2) {
+      return span;
+    }
+  }
+  return null;
+}
+function getRowActionInsertPoint(actionContainer) {
+  const buttons = Array.from(actionContainer.querySelectorAll(":scope > button"));
+  if (buttons.length === 0) {
+    return null;
+  }
+  const reorderButton = buttons.find((button) => {
+    if (!(button instanceof HTMLButtonElement)) {
+      return false;
+    }
+    const label = button.querySelector("span")?.textContent?.trim().toLowerCase() ?? "";
+    return label === "drag" || label === "move up" || label === "move down" || button.hasAttribute("data-handler-id");
+  });
+  return reorderButton ?? buttons[1] ?? null;
+}
+function disambiguateZonePathByRowLabel(rowElement, candidates, values, index2) {
+  const rowText = (rowElement.textContent || "").toLowerCase();
+  const matches = candidates.filter((fieldName) => {
+    const entry = getValueAtPath(values, `${fieldName}.${index2}`);
+    if (!isDynamicZoneEntry(entry)) {
+      return false;
+    }
+    const componentUid = entry.__component.split(".").pop() || entry.__component;
+    return rowText.includes(componentUid.toLowerCase()) || rowText.includes(fieldName.toLowerCase());
+  });
+  return matches.length === 1 ? matches[0] : null;
+}
+function resolveBlockFromListItemIndex(listElement, index2, values, zonePaths) {
+  const rowCount = getDynamicZoneListItems(listElement).length;
+  const candidates = zonePaths.filter((fieldName) => {
+    const zone = values[fieldName];
+    return Array.isArray(zone) && zone.length === rowCount;
+  });
+  if (candidates.length === 1) {
+    return { zonePath: candidates[0], index: index2 };
+  }
+  if (candidates.length > 1) {
+    const rowElement = getDynamicZoneListItems(listElement)[index2];
+    const zonePath = rowElement ? disambiguateZonePathByRowLabel(rowElement, candidates, values, index2) : null;
+    if (zonePath) {
+      return { zonePath, index: index2 };
+    }
+  }
+  return null;
+}
+function resolveBlockFromListItem(listItem, values) {
+  const fieldNames = Array.from(listItem.querySelectorAll("[name]")).map((element) => element.getAttribute("name") || "").filter(Boolean).sort((a, b) => a.length - b.length);
+  for (const fieldName of fieldNames) {
+    const segments = fieldName.split(".");
+    for (let indexPosition = segments.length - 2; indexPosition >= 0; indexPosition -= 1) {
+      const segment = segments[indexPosition];
+      if (!INDEX_SEGMENT.test(segment)) {
+        continue;
+      }
+      const itemPath = segments.slice(0, indexPosition + 1).join(".");
+      const zonePath = segments.slice(0, indexPosition).join(".");
+      const index2 = Number(segment);
+      const itemValue = getValueAtPath(values, itemPath);
+      if (isDynamicZoneEntry(itemValue) && Array.isArray(getValueAtPath(values, zonePath))) {
+        return { zonePath, index: index2 };
+      }
+    }
+  }
+  const list = listItem.closest("ol[aria-describedby]");
+  const zonePaths = getDynamicZonePathsFromValues(values);
+  if (list && zonePaths.length > 0) {
+    const index2 = getDynamicZoneListItems(list).indexOf(listItem);
+    if (index2 >= 0) {
+      return resolveBlockFromListItemIndex(list, index2, values, zonePaths);
+    }
+  }
+  return null;
+}
+function getButtonLabel(button) {
+  return button.querySelector("span")?.textContent?.trim().toLowerCase() ?? "";
+}
+function findDynamicZoneDragHandles(root = document) {
+  return Array.from(root.querySelectorAll("button[data-handler-id], button")).filter(
+    (button) => {
+      const label = getButtonLabel(button);
+      return label === "drag" || button.hasAttribute("data-handler-id");
+    }
+  );
+}
+function findRowElementForDragHandle(dragHandle) {
+  return dragHandle.closest("li");
+}
+const TOOLS_DIALOG_STYLE_ID = `${PLUGIN_ID}-dialog-layout-styles`;
+function ensureToolsDialogStyles() {
+  const dom = globalThis.document;
+  if (!dom || dom.getElementById(TOOLS_DIALOG_STYLE_ID)) {
+    return;
+  }
+  const style = dom.createElement("style");
+  style.id = TOOLS_DIALOG_STYLE_ID;
+  style.textContent = `
+    [role='alertdialog'][data-dz-tools-dialog='true'] {
+      max-height: calc(100dvh - 2rem) !important;
+      height: auto !important;
+      overflow: hidden !important;
+    }
+
+    [data-dz-tools-dialog='true'] [data-dz-tools-shell='true'] {
+      display: flex;
+      flex: 1 1 auto;
+      flex-direction: column;
+      min-height: 0;
+      overflow: hidden;
+      width: 100%;
+    }
+
+    [data-dz-tools-dialog='true'] [data-dz-tools-body='true'] {
+      flex: 1 1 auto !important;
+      min-height: 0 !important;
+      overflow-y: auto !important;
+    }
+
+    [data-dz-tools-dialog='true'] [data-dz-tools-footer='true'] {
+      flex: 0 0 auto !important;
+    }
+  `;
+  dom.head.appendChild(style);
+}
+const DynamicZoneToolsHeaderAction = ({
+  document: document2,
+  documentId,
+  meta,
+  model,
+  collectionType,
+  activeTab
+}) => {
+  const schemaAttributes = meta?.schema?.attributes || meta?.attributes || null;
+  if (schemaAttributes) {
+    const hasDynamicZone = Object.values(schemaAttributes).some(
+      (attr) => attr?.type === "dynamiczone"
+    );
+    if (!hasDynamicZone) return null;
+  }
+  return {
+    type: "icon",
+    icon: /* @__PURE__ */ jsx(Duplicate, {}),
+    label: "Copy dynamic zone data",
+    dialog: {
+      type: "dialog",
+      title: "Dynamic Zone Tools",
+      content: ({ onClose }) => /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(
+        DynamicZoneToolsDialog,
+        {
+          document: document2,
+          documentId,
+          model,
+          collectionType,
+          activeTab,
+          schemaAttributes,
+          onClose
+        }
+      ) })
+    }
+  };
+};
+const DynamicZoneToolsDialog = ({
+  document: document2,
+  documentId,
+  model,
+  collectionType,
+  activeTab,
+  schemaAttributes,
+  onClose
+}) => {
+  const { formatMessage } = useIntl();
+  const { get } = useFetchClient();
+  const { setValues, values } = useForm("DynamicZoneTools", (state) => ({
+    setValues: state.setValues,
+    values: state.values
+  }));
+  const { toggleNotification } = useNotification();
+  const parsePayloadData = (payload) => {
+    if (payload?.data && typeof payload.data === "object") return payload.data;
+    if (payload && typeof payload === "object") return payload;
+    return null;
+  };
+  const getDynamicZonesFromAttributes = (attributes) => getDynamicZoneFields(attributes);
+  const [targetDynamicZones, setTargetDynamicZones] = useState([]);
+  const [selectedTargetZone, setSelectedTargetZone] = useState("");
+  const [contentTypes, setContentTypes] = useState([]);
+  const [selectedContentType, setSelectedContentType] = useState("");
+  const [sourceDynamicZones, setSourceDynamicZones] = useState([]);
+  const [selectedSourceZone, setSelectedSourceZone] = useState("");
+  const [records, setRecords] = useState([]);
+  const [selectedRecord, setSelectedRecord] = useState("");
+  const [configuredLocales, setConfiguredLocales] = useState([]);
+  const [selectedLocale, setSelectedLocale] = useState("");
+  const [selectedVersion, setSelectedVersion] = useState("draft");
+  const [recordsLoading, setRecordsLoading] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState("");
+  const [fillMode, setFillMode] = useState("replace");
+  const [sourcePreviewLoading, setSourcePreviewLoading] = useState(false);
+  const [sourceZoneEntries, setSourceZoneEntries] = useState([]);
+  const [selectedBlockIndexes, setSelectedBlockIndexes] = useState(/* @__PURE__ */ new Set());
+  const sourceContentType = contentTypes.find((ct) => ct.uid === selectedContentType);
+  const sourceHasDraftAndPublish = sourceContentType?.draftAndPublish ?? false;
+  const sourceIsLocalized = (sourceContentType?.localized ?? false) && configuredLocales.length > 0;
+  const selectedRecordEntry = records.find(
+    (record) => (record.documentId || record.id.toString()) === selectedRecord
+  );
+  const selectedRecordHasPublished = selectedRecordEntry?.status === "published" || selectedRecordEntry?.status === "modified";
+  useEffect(() => {
+    if (schemaAttributes) {
+      setTargetDynamicZones(getDynamicZonesFromAttributes(schemaAttributes));
+    } else {
+      const currentType = contentTypes.find((ct) => ct.uid === model);
+      setTargetDynamicZones(currentType?.dynamicZones || []);
+    }
+  }, [schemaAttributes, contentTypes, model]);
+  useEffect(() => {
+    const fetchContentTypes = async () => {
+      try {
+        const response = await get("/content-manager/content-types");
+        let contentTypesData = response.data || response;
+        if (!Array.isArray(contentTypesData)) {
+          if (contentTypesData.data && Array.isArray(contentTypesData.data)) {
+            contentTypesData = contentTypesData.data;
+          } else if (contentTypesData.results && Array.isArray(contentTypesData.results)) {
+            contentTypesData = contentTypesData.results;
+          } else {
+            contentTypesData = [];
+          }
+        }
+        const typesWithDynamicZones = contentTypesData.map((ct) => {
+          const attributes = ct.attributes || ct.schema?.attributes;
+          const dynamicZones = getDynamicZonesFromAttributes(attributes);
+          return {
+            uid: ct.uid,
+            displayName: ct.info?.displayName || ct.schema?.displayName || ct.uid,
+            draftAndPublish: Boolean(
+              ct.options?.draftAndPublish ?? ct.schema?.options?.draftAndPublish
+            ),
+            localized: Boolean(
+              ct.pluginOptions?.i18n?.localized ?? ct.schema?.pluginOptions?.i18n?.localized
+            ),
+            dynamicZones
+          };
+        }).filter((ct) => ct.dynamicZones.length > 0);
+        setContentTypes(typesWithDynamicZones);
+      } catch (err) {
+        setError("Failed to load content types");
+        console.error("Error loading content types:", err);
+      }
+    };
+    fetchContentTypes();
+  }, [get]);
+  React.useLayoutEffect(() => {
+    ensureToolsDialogStyles();
+  }, []);
+  const dialogLayoutRef = React.useCallback((node) => {
+    const markDialog = () => {
+      const dialogContent = node?.closest('[role="alertdialog"]');
+      if (dialogContent instanceof HTMLElement) {
+        dialogContent.setAttribute("data-dz-tools-dialog", "true");
+      }
+    };
+    if (!node) {
+      return;
+    }
+    markDialog();
+    requestAnimationFrame(markDialog);
+  }, []);
+  React.useLayoutEffect(() => {
+    return () => {
+      const dom = globalThis.document;
+      if (!dom) {
+        return;
+      }
+      dom.querySelectorAll('[data-dz-tools-dialog="true"]').forEach((element) => {
+        element.removeAttribute("data-dz-tools-dialog");
+      });
+    };
+  }, []);
+  useEffect(() => {
+    if (!selectedContentType) {
+      setSourceDynamicZones([]);
+      return;
+    }
+    const selectedType = contentTypes.find((ct) => ct.uid === selectedContentType);
+    if (!selectedType) return;
+    setSourceDynamicZones(selectedType.dynamicZones);
+  }, [selectedContentType, contentTypes]);
+  useEffect(() => {
+    const fetchRecords = async () => {
+      if (!selectedContentType || sourceIsLocalized && !selectedLocale) {
+        setRecords([]);
+        return;
+      }
+      try {
+        setRecordsLoading(true);
+        const requestParams = new URLSearchParams({
+          page: "1",
+          pageSize: "500"
+        });
+        if (sourceIsLocalized) requestParams.set("locale", selectedLocale);
+        const response = await get(
+          `/content-manager/collection-types/${encodeURIComponent(
+            selectedContentType
+          )}?${requestParams.toString()}`
+        );
+        let recordsData = [];
+        if (response.data) {
+          if (Array.isArray(response.data)) {
+            recordsData = response.data;
+          } else if (response.data.results && Array.isArray(response.data.results)) {
+            recordsData = response.data.results;
+          } else if (response.data.data && Array.isArray(response.data.data)) {
+            recordsData = response.data.data;
+          }
+        }
+        setRecords(recordsData);
+      } catch (err) {
+        setError("Failed to load records");
+        console.error("Error loading records:", err);
+      } finally {
+        setRecordsLoading(false);
+      }
+    };
+    fetchRecords();
+  }, [selectedContentType, sourceIsLocalized, selectedLocale, get]);
+  useEffect(() => {
+    const fetchLocales = async () => {
+      try {
+        const response = await get("/i18n/locales");
+        const locales = Array.isArray(response.data) ? response.data : response.data?.data ?? [];
+        setConfiguredLocales(
+          locales.filter((locale) => locale?.code).map((locale) => ({
+            code: locale.code,
+            name: locale.name || locale.code,
+            isDefault: Boolean(locale.isDefault)
+          }))
+        );
+      } catch {
+      }
+    };
+    fetchLocales();
+  }, [get]);
+  useEffect(() => {
+    if (!selectedContentType || !sourceIsLocalized) {
+      setSelectedLocale("");
+      return;
+    }
+    const currentLocale = document2?.locale ?? null;
+    const defaultLocale = configuredLocales.find((locale) => locale.code === currentLocale)?.code ?? configuredLocales.find((locale) => locale.isDefault)?.code ?? configuredLocales[0]?.code ?? "";
+    setSelectedLocale(defaultLocale);
+  }, [selectedContentType, sourceIsLocalized, configuredLocales, document2?.locale]);
+  const [componentSchemas, setComponentSchemas] = useState(null);
+  const fetchComponentSchemas = async () => {
+    if (componentSchemas) return componentSchemas;
+    const map = await loadComponentSchemas(get);
+    setComponentSchemas(map);
+    return map;
+  };
+  const getRecordLabel = (record) => {
+    const rawLabel = record.title || record.name || `Document ${record.documentId || record.id}`;
+    const maxLength = 60;
+    return rawLabel.length > maxLength ? `${rawLabel.substring(0, maxLength)}...` : rawLabel;
+  };
+  const getLocaleLabel = (code) => {
+    const name = configuredLocales.find((locale) => locale.code === code)?.name;
+    if (!name) return code;
+    return name.includes(`(${code})`) ? name : `${name} (${code})`;
+  };
+  const getSelectString = (value) => String(value);
+  const canFetchSourcePreview = Boolean(selectedContentType && selectedSourceZone && selectedRecord) && (!sourceIsLocalized || Boolean(selectedLocale));
+  const buildSourceDocumentQuery = () => {
+    const urlParams = new URLSearchParams(window.location.search);
+    const urlLocale = urlParams.get("plugins[i18n][locale]");
+    const locale = selectedLocale || urlLocale;
+    const requestParams = new URLSearchParams();
+    if (locale) requestParams.set("locale", locale);
+    if (sourceHasDraftAndPublish) requestParams.set("status", selectedVersion);
+    return requestParams.toString() ? `?${requestParams.toString()}` : "";
+  };
+  useEffect(() => {
+    if (!canFetchSourcePreview) {
+      setSourceZoneEntries([]);
+      setSelectedBlockIndexes(/* @__PURE__ */ new Set());
+      return;
+    }
+    let active = true;
+    const fetchSourcePreview = async () => {
+      try {
+        setSourcePreviewLoading(true);
+        setError("");
+        const localeQuery = buildSourceDocumentQuery();
+        const response = await get(
+          `/${PLUGIN_ID}/source-document/${encodeURIComponent(
+            selectedContentType
+          )}/${selectedRecord}${localeQuery}`
+        );
+        const sourceDocument = parsePayloadData(response.data ?? response);
+        const zoneData = sourceDocument?.[selectedSourceZone];
+        if (!active) return;
+        if (!Array.isArray(zoneData) || zoneData.length === 0) {
+          setSourceZoneEntries([]);
+          setSelectedBlockIndexes(/* @__PURE__ */ new Set());
+          return;
+        }
+        setSourceZoneEntries(zoneData);
+        setSelectedBlockIndexes(new Set(zoneData.map((_, index2) => index2)));
+      } catch {
+        if (active) {
+          setSourceZoneEntries([]);
+          setSelectedBlockIndexes(/* @__PURE__ */ new Set());
+        }
+      } finally {
+        if (active) {
+          setSourcePreviewLoading(false);
+        }
+      }
+    };
+    void fetchSourcePreview();
+    return () => {
+      active = false;
+    };
+  }, [
+    canFetchSourcePreview,
+    get,
+    selectedContentType,
+    selectedRecord,
+    selectedSourceZone,
+    selectedLocale,
+    selectedVersion,
+    sourceHasDraftAndPublish
+  ]);
+  const selectAllBlocks = () => {
+    setSelectedBlockIndexes(new Set(sourceZoneEntries.map((_, index2) => index2)));
+  };
+  const clearAllBlocks = () => {
+    setSelectedBlockIndexes(/* @__PURE__ */ new Set());
+  };
+  const handleConfirmFill = async () => {
+    if (!selectedTargetZone || !selectedContentType || !selectedSourceZone || !selectedRecord)
+      return;
+    if (selectedBlockIndexes.size === 0) {
+      setError("Select at least one block to copy");
+      return;
+    }
+    try {
+      setLoading(true);
+      setError("");
+      const schemas = await fetchComponentSchemas();
+      const sourceData = sourceZoneEntries.length > 0 ? sourceZoneEntries : (() => {
+        throw new Error("Source blocks are not loaded yet");
+      })();
+      const selectedEntries = sourceData.filter((_, index2) => selectedBlockIndexes.has(index2));
+      const allowedComponents = schemaAttributes?.[selectedTargetZone]?.components;
+      const { allowed: allowedData, skippedCount } = filterAllowedDynamicZoneEntries(
+        selectedEntries,
+        allowedComponents
+      );
+      if (allowedData.length === 0) {
+        setError("None of the selected components are allowed in the target dynamic zone");
+        return;
+      }
+      const currentZone = Array.isArray(values?.[selectedTargetZone]) ? values[selectedTargetZone] : [];
+      const cleanedData = fillMode === "append" ? prepareZoneDataForInsert(allowedData, schemas, {
+        previousKey: currentZone.at(-1)?.__temp_key__ ?? null,
+        nextKey: null
+      }) : prepareZoneData(allowedData, schemas);
+      setValues({
+        ...values,
+        [selectedTargetZone]: fillMode === "append" ? [...currentZone, ...cleanedData] : cleanedData
+      });
+      toggleNotification({
+        type: skippedCount > 0 ? "warning" : "success",
+        message: skippedCount > 0 ? formatMessage(
+          {
+            id: `${PLUGIN_ID}.notification.partial`,
+            defaultMessage: "Content copied, but {count} component(s) were skipped because the target zone does not allow them."
+          },
+          { count: skippedCount }
+        ) : formatMessage({
+          id: fillMode === "append" ? `${PLUGIN_ID}.notification.append-success` : `${PLUGIN_ID}.notification.success`,
+          defaultMessage: fillMode === "append" ? "Selected blocks appended successfully!" : "Dynamic zone content copied successfully!"
+        })
+      });
+      setSelectedTargetZone("");
+      setSelectedContentType("");
+      setSelectedSourceZone("");
+      setSelectedRecord("");
+      setSelectedVersion("draft");
+      setFillMode("replace");
+      setSourceZoneEntries([]);
+      setSelectedBlockIndexes(/* @__PURE__ */ new Set());
+      onClose();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fill in data";
+      setError(errorMessage);
+      toggleNotification({
+        type: "warning",
+        message: errorMessage
+      });
+    } finally {
+      setLoading(false);
+    }
+  };
+  const isFormValid = selectedTargetZone && selectedContentType && selectedSourceZone && selectedRecord && (!sourceIsLocalized || selectedLocale) && selectedBlockIndexes.size > 0 && !sourcePreviewLoading;
+  return /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      ref: dialogLayoutRef,
+      "data-dz-tools-shell": "true",
+      direction: "column",
+      alignItems: "stretch",
+      width: "100%",
+      children: [
+        /* @__PURE__ */ jsx(Dialog.Body, { "data-dz-tools-body": "true", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 4, width: "100%", alignItems: "stretch", children: [
+          /* @__PURE__ */ jsxs(
+            Flex,
+            {
+              gap: 3,
+              padding: 4,
+              background: fillMode === "replace" ? "danger100" : "primary100",
+              hasRadius: true,
+              alignItems: "flex-start",
+              width: "100%",
+              children: [
+                /* @__PURE__ */ jsx(Box, { style: { flexShrink: 0, display: "flex" }, paddingTop: 1, children: /* @__PURE__ */ jsx(WarningCircle, { fill: fillMode === "replace" ? "danger600" : "primary600" }) }),
+                /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, alignItems: "flex-start", children: [
+                  /* @__PURE__ */ jsx(
+                    Typography,
+                    {
+                      fontWeight: "semiBold",
+                      textColor: fillMode === "replace" ? "danger700" : "primary700",
+                      children: fillMode === "replace" ? formatMessage({
+                        id: `${PLUGIN_ID}.modal.warning`,
+                        defaultMessage: "This will replace the current content of the target dynamic zone."
+                      }) : formatMessage({
+                        id: `${PLUGIN_ID}.modal.append-info`,
+                        defaultMessage: "Selected blocks will be appended to the end of the target dynamic zone."
+                      })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    Typography,
+                    {
+                      variant: "pi",
+                      textColor: fillMode === "replace" ? "danger600" : "primary600",
+                      children: formatMessage({
+                        id: `${PLUGIN_ID}.modal.warning.helper`,
+                        defaultMessage: "Nothing is saved yet — review the result and save the document to keep it."
+                      })
+                    }
+                  )
+                ] })
+              ]
+            }
+          ),
+          error && /* @__PURE__ */ jsx(Alert, { closeLabel: "Close", title: "Error", variant: "danger", onClose: () => setError(""), children: error }),
+          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.fill-mode.label`,
+              defaultMessage: "Copy mode"
+            }) }),
+            /* @__PURE__ */ jsxs(
+              SingleSelect,
+              {
+                value: fillMode,
+                onChange: (value) => setFillMode(value === "append" ? "append" : "replace"),
+                disabled: loading,
+                size: "S",
+                children: [
+                  /* @__PURE__ */ jsx(SingleSelectOption, { value: "replace", children: formatMessage({
+                    id: `${PLUGIN_ID}.fill-mode.replace`,
+                    defaultMessage: "Replace current zone"
+                  }) }),
+                  /* @__PURE__ */ jsx(SingleSelectOption, { value: "append", children: formatMessage({
+                    id: `${PLUGIN_ID}.fill-mode.append`,
+                    defaultMessage: "Append to current zone"
+                  }) })
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.target-zone.label`,
+              defaultMessage: "Target Dynamic Zone"
+            }) }),
+            /* @__PURE__ */ jsx(
+              SingleSelect,
+              {
+                placeholder: formatMessage({
+                  id: `${PLUGIN_ID}.target-zone.placeholder`,
+                  defaultMessage: "Select zone to fill"
+                }),
+                value: selectedTargetZone,
+                onChange: (value) => {
+                  setSelectedTargetZone(getSelectString(value));
+                  setSelectedContentType("");
+                  setSelectedSourceZone("");
+                  setSelectedRecord("");
+                  setSelectedVersion("draft");
+                },
+                disabled: loading,
+                size: "S",
+                children: targetDynamicZones.map((zone) => /* @__PURE__ */ jsx(SingleSelectOption, { value: zone.fieldName, children: zone.displayName }, zone.fieldName))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.source-collection.label`,
+              defaultMessage: "Source Collection"
+            }) }),
+            /* @__PURE__ */ jsx(
+              SingleSelect,
+              {
+                placeholder: formatMessage({
+                  id: `${PLUGIN_ID}.source-collection.placeholder`,
+                  defaultMessage: "Select source collection"
+                }),
+                value: selectedContentType,
+                onChange: (value) => {
+                  setSelectedContentType(getSelectString(value));
+                  setSelectedSourceZone("");
+                  setSelectedRecord("");
+                  setSelectedVersion("draft");
+                },
+                disabled: !selectedTargetZone || loading,
+                size: "S",
+                children: contentTypes.map((ct) => /* @__PURE__ */ jsx(SingleSelectOption, { value: ct.uid, children: ct.displayName }, ct.uid))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.source-zone.label`,
+              defaultMessage: "Source Dynamic Zone"
+            }) }),
+            /* @__PURE__ */ jsx(
+              SingleSelect,
+              {
+                placeholder: formatMessage({
+                  id: `${PLUGIN_ID}.source-zone.placeholder`,
+                  defaultMessage: "Select zone to copy from"
+                }),
+                value: selectedSourceZone,
+                onChange: (value) => {
+                  setSelectedSourceZone(getSelectString(value));
+                  setSelectedRecord("");
+                  setSelectedVersion("draft");
+                },
+                disabled: !selectedContentType || loading,
+                size: "S",
+                children: sourceDynamicZones.map((zone) => /* @__PURE__ */ jsx(SingleSelectOption, { value: zone.fieldName, children: zone.displayName }, zone.fieldName))
+              }
+            )
+          ] }),
+          sourceIsLocalized && /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.source-locale.label`,
+              defaultMessage: "Source Locale"
+            }) }),
+            /* @__PURE__ */ jsx(
+              SingleSelect,
+              {
+                value: selectedLocale,
+                onChange: (value) => {
+                  setSelectedLocale(getSelectString(value));
+                  setSelectedRecord("");
+                  setSelectedVersion("draft");
+                },
+                disabled: !selectedSourceZone || loading,
+                size: "S",
+                children: configuredLocales.map((locale) => /* @__PURE__ */ jsx(SingleSelectOption, { value: locale.code, children: getLocaleLabel(locale.code) }, locale.code))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.source-record.label`,
+              defaultMessage: "Source Record"
+            }) }),
+            /* @__PURE__ */ jsx(
+              SingleSelect,
+              {
+                placeholder: recordsLoading ? formatMessage({
+                  id: `${PLUGIN_ID}.source-record.loading`,
+                  defaultMessage: "Loading records..."
+                }) : formatMessage({
+                  id: `${PLUGIN_ID}.source-record.placeholder`,
+                  defaultMessage: "Select record to copy from"
+                }),
+                value: selectedRecord,
+                onChange: (value) => {
+                  setSelectedRecord(getSelectString(value));
+                  setSelectedVersion("draft");
+                },
+                disabled: !selectedSourceZone || recordsLoading || loading || sourceIsLocalized && !selectedLocale,
+                size: "S",
+                children: records.map((record) => /* @__PURE__ */ jsx(
+                  SingleSelectOption,
+                  {
+                    value: record.documentId || record.id.toString(),
+                    children: getRecordLabel(record)
+                  },
+                  record.documentId || record.id
+                ))
+              }
+            )
+          ] }),
+          sourceHasDraftAndPublish && /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 1, width: "100%", children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+              id: `${PLUGIN_ID}.source-version.label`,
+              defaultMessage: "Source Version"
+            }) }),
+            /* @__PURE__ */ jsxs(
+              SingleSelect,
+              {
+                value: selectedVersion,
+                onChange: (value) => setSelectedVersion(value === "published" ? "published" : "draft"),
+                disabled: !selectedRecord || loading,
+                size: "S",
+                children: [
+                  /* @__PURE__ */ jsx(SingleSelectOption, { value: "draft", children: formatMessage({
+                    id: `${PLUGIN_ID}.source-version.draft`,
+                    defaultMessage: "Draft"
+                  }) }),
+                  /* @__PURE__ */ jsx(SingleSelectOption, { value: "published", disabled: !selectedRecordHasPublished, children: selectedRecord && !selectedRecordHasPublished ? formatMessage({
+                    id: `${PLUGIN_ID}.source-version.published-unavailable`,
+                    defaultMessage: "Published (not available)"
+                  }) : formatMessage({
+                    id: `${PLUGIN_ID}.source-version.published`,
+                    defaultMessage: "Published"
+                  }) })
+                ]
+              }
+            )
+          ] }),
+          canFetchSourcePreview && /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, width: "100%", children: [
+            /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", width: "100%", children: [
+              /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral800", children: formatMessage({
+                id: `${PLUGIN_ID}.source-blocks.label`,
+                defaultMessage: "Blocks to copy"
+              }) }),
+              /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+                /* @__PURE__ */ jsx(Button, { variant: "tertiary", size: "S", onClick: selectAllBlocks, disabled: loading, children: formatMessage({
+                  id: `${PLUGIN_ID}.source-blocks.select-all`,
+                  defaultMessage: "Select all"
+                }) }),
+                /* @__PURE__ */ jsx(Button, { variant: "tertiary", size: "S", onClick: clearAllBlocks, disabled: loading, children: formatMessage({
+                  id: `${PLUGIN_ID}.source-blocks.clear-all`,
+                  defaultMessage: "Clear all"
+                }) })
+              ] })
+            ] }),
+            sourcePreviewLoading ? /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", children: formatMessage({
+              id: `${PLUGIN_ID}.source-blocks.loading`,
+              defaultMessage: "Loading source blocks..."
+            }) }) : sourceZoneEntries.length === 0 ? /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", children: formatMessage({
+              id: `${PLUGIN_ID}.source-blocks.empty`,
+              defaultMessage: "No blocks found in the selected source zone."
+            }) }) : /* @__PURE__ */ jsx(
+              Flex,
+              {
+                direction: "column",
+                gap: 2,
+                width: "100%",
+                padding: 3,
+                background: "neutral100",
+                hasRadius: true,
+                children: sourceZoneEntries.map((entry, index2) => {
+                  const componentUid = entry?.__component ?? "";
+                  const label = getDynamicZoneEntryLabel(entry);
+                  const componentName = getComponentDisplayName(componentUid);
+                  const allowedComponents = schemaAttributes?.[selectedTargetZone]?.components;
+                  const isAllowed = !Array.isArray(allowedComponents) || allowedComponents.includes(componentUid);
+                  return /* @__PURE__ */ jsxs(
+                    Checkbox,
+                    {
+                      checked: selectedBlockIndexes.has(index2),
+                      onCheckedChange: (checked) => {
+                        setSelectedBlockIndexes((current) => {
+                          const next = new Set(current);
+                          if (checked === true) {
+                            next.add(index2);
+                          } else {
+                            next.delete(index2);
+                          }
+                          return next;
+                        });
+                      },
+                      disabled: loading || !isAllowed,
+                      children: [
+                        componentName,
+                        label ? ` · ${label}` : "",
+                        !isAllowed ? ` (${formatMessage({
+                          id: `${PLUGIN_ID}.source-blocks.not-allowed`,
+                          defaultMessage: "not allowed in target zone"
+                        })})` : ""
+                      ]
+                    },
+                    `${componentUid}-${index2}`
+                  );
+                })
+              }
+            )
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsxs(Dialog.Footer, { "data-dz-tools-footer": "true", children: [
+          /* @__PURE__ */ jsx(Button, { variant: "tertiary", fullWidth: true, onClick: onClose, disabled: loading, children: formatMessage({
+            id: `${PLUGIN_ID}.modal.cancel`,
+            defaultMessage: "No, cancel"
+          }) }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "default",
+              fullWidth: true,
+              onClick: handleConfirmFill,
+              loading,
+              disabled: !isFormValid,
+              children: formatMessage({
+                id: `${PLUGIN_ID}.modal.confirm`,
+                defaultMessage: "Yes, fill in"
+              })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+const DUPLICATE_ICON_PATH = "M27 4H11a1 1 0 0 0-1 1v5H5a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h16a1 1 0 0 0 1-1v-5h5a1 1 0 0 0 1-1V5a1 1 0 0 0-1-1m-1 16h-4v-9a1 1 0 0 0-1-1h-9V6h14z";
+const COPY_BLOCK_ICON_PATH = "M27.5 21.136 16 27.843 4.5 21.136a1 1 0 0 0-1 1.728l12 7a1 1 0 0 0 1.008 0l12-7a1 1 0 1 0-1.008-1.728M27.5 15.136 16 21.843 4.5 15.136a1 1 0 0 0-1 1.728l12 7a1 1 0 0 0 1.008 0l12-7a1 1 0 1 0-1.008-1.728m-24-4.272 12 7a1 1 0 0 0 1.008 0l12-7a1 1 0 0 0 0-1.728l-12-7a1 1 0 0 0-1.008 0l-12 7a1 1 0 0 0 0 1.728";
+const CARET_DOWN_ICON_PATH = "m26.708 12.708-10 10a1 1 0 0 1-1.415 0l-10-10A1 1 0 0 1 6 11h20a1 1 0 0 1 .707 1.707";
+function createRowActionButton(templateButton, label, iconPath, onClick, signal) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = templateButton.className;
+  button.setAttribute("aria-label", label);
+  button.setAttribute("title", label);
+  button.setAttribute("data-state", "closed");
+  const icon = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  icon.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  icon.setAttribute("viewBox", "0 0 32 32");
+  icon.setAttribute("width", "16");
+  icon.setAttribute("height", "16");
+  icon.setAttribute("fill", "currentColor");
+  icon.setAttribute("aria-hidden", "true");
+  icon.setAttribute("focusable", "false");
+  const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+  path.setAttribute("d", iconPath);
+  icon.appendChild(path);
+  const text = document.createElement("span");
+  const templateLabel = templateButton.querySelector("span");
+  text.className = templateLabel?.className ?? "sc-kkmxCq hTCBro";
+  text.textContent = label;
+  button.append(icon, text);
+  button.addEventListener(
+    "click",
+    (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      onClick();
+    },
+    { signal }
+  );
+  return button;
+}
+function createSvgIcon(iconPath, viewBox = "0 0 32 32") {
+  const icon = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  icon.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  icon.setAttribute("viewBox", viewBox);
+  icon.setAttribute("width", "16");
+  icon.setAttribute("height", "16");
+  icon.setAttribute("fill", "currentColor");
+  icon.setAttribute("aria-hidden", "true");
+  icon.setAttribute("focusable", "false");
+  const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+  path.setAttribute("d", iconPath);
+  icon.appendChild(path);
+  return icon;
+}
+function positionMenu(trigger, menu) {
+  const rect = trigger.getBoundingClientRect();
+  menu.style.position = "fixed";
+  menu.style.top = `${rect.bottom + 4}px`;
+  menu.style.left = `${Math.max(8, rect.right - menu.offsetWidth)}px`;
+}
+function closeOpenMenus(exceptMenuId) {
+  for (const menu of document.querySelectorAll('[data-dz-tools-row-menu="true"]')) {
+    if (!(menu instanceof HTMLElement)) {
+      continue;
+    }
+    const menuId = menu.getAttribute("data-dz-tools-row-menu-id");
+    if (menuId && menuId === exceptMenuId) {
+      continue;
+    }
+    menu.hidden = true;
+    const triggerId = menu.getAttribute("data-dz-tools-row-menu-trigger-id");
+    const trigger = triggerId ? document.querySelector(`[data-dz-tools-row-menu-trigger-id="${triggerId}"]`) : null;
+    if (trigger instanceof HTMLButtonElement) {
+      trigger.setAttribute("aria-expanded", "false");
+    }
+  }
+}
+let openInsertMenuCount = 0;
+function getOpenInsertMenuCount() {
+  return openInsertMenuCount;
+}
+function createRowActionMenu(templateButton, label, items, signal, options = {}) {
+  const menuId = `dz-tools-menu-${Math.random().toString(36).slice(2)}`;
+  const triggerId = `dz-tools-trigger-${Math.random().toString(36).slice(2)}`;
+  const wrapper = document.createElement("span");
+  wrapper.style.display = "inline-flex";
+  const trigger = document.createElement("button");
+  trigger.type = "button";
+  trigger.className = templateButton.className;
+  trigger.setAttribute("aria-label", label);
+  trigger.setAttribute("title", label);
+  trigger.setAttribute("aria-haspopup", "menu");
+  trigger.setAttribute("aria-expanded", "false");
+  trigger.setAttribute("data-state", "closed");
+  trigger.setAttribute("data-dz-tools-row-menu-trigger-id", triggerId);
+  const text = document.createElement("span");
+  const templateLabel = templateButton.querySelector("span");
+  text.className = templateLabel?.className ?? "sc-kkmxCq hTCBro";
+  text.textContent = label;
+  trigger.append(createSvgIcon(CARET_DOWN_ICON_PATH), text);
+  const menu = document.createElement("div");
+  menu.setAttribute("data-dz-tools-row-menu", "true");
+  menu.setAttribute("data-dz-tools-row-menu-id", menuId);
+  menu.setAttribute("data-dz-tools-row-menu-trigger-id", triggerId);
+  menu.setAttribute("role", "menu");
+  menu.hidden = true;
+  menu.style.zIndex = "10000";
+  menu.style.minWidth = "180px";
+  menu.style.padding = "4px";
+  menu.style.borderRadius = "4px";
+  menu.style.background = "var(--strapi-neutral-0, #ffffff)";
+  menu.style.border = "1px solid var(--strapi-neutral-200, #dcdce4)";
+  menu.style.boxShadow = "0 2px 15px rgba(33, 33, 52, 0.15)";
+  for (const item of items) {
+    const menuItem = document.createElement("button");
+    menuItem.type = "button";
+    menuItem.setAttribute("role", "menuitem");
+    menuItem.textContent = item.label;
+    menuItem.disabled = Boolean(item.disabled);
+    menuItem.style.display = "block";
+    menuItem.style.width = "100%";
+    menuItem.style.padding = "8px 12px";
+    menuItem.style.border = "none";
+    menuItem.style.background = "transparent";
+    menuItem.style.textAlign = "left";
+    menuItem.style.font = "inherit";
+    menuItem.style.fontSize = "1.2rem";
+    menuItem.style.lineHeight = "1.33";
+    menuItem.style.color = item.disabled ? "var(--strapi-neutral-400, #a5a5ba)" : "var(--strapi-neutral-800, #32324d)";
+    menuItem.style.cursor = item.disabled ? "not-allowed" : "pointer";
+    menuItem.style.borderRadius = "4px";
+    if (!item.disabled) {
+      menuItem.addEventListener("mouseenter", () => {
+        menuItem.style.background = "var(--strapi-neutral-100, #f6f6f9)";
+      });
+      menuItem.addEventListener("mouseleave", () => {
+        menuItem.style.background = "transparent";
+      });
+    }
+    menuItem.addEventListener(
+      "click",
+      (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        if (item.disabled) {
+          return;
+        }
+        menu.hidden = true;
+        trigger.setAttribute("aria-expanded", "false");
+        item.onSelect();
+      },
+      { signal }
+    );
+    menu.appendChild(menuItem);
+  }
+  const openMenu = () => {
+    if (!document.body.contains(menu)) {
+      document.body.appendChild(menu);
+    }
+    menu.hidden = false;
+    openInsertMenuCount += 1;
+    requestAnimationFrame(() => {
+      positionMenu(trigger, menu);
+    });
+    trigger.setAttribute("aria-expanded", "true");
+  };
+  const closeMenu = () => {
+    if (menu.hidden) {
+      return;
+    }
+    menu.hidden = true;
+    openInsertMenuCount = Math.max(0, openInsertMenuCount - 1);
+    trigger.setAttribute("aria-expanded", "false");
+  };
+  trigger.addEventListener(
+    "click",
+    (event) => {
+      void (async () => {
+        event.preventDefault();
+        event.stopPropagation();
+        const willOpen = menu.hidden;
+        closeOpenMenus(willOpen ? menuId : void 0);
+        if (!willOpen) {
+          closeMenu();
+          return;
+        }
+        if (options.onBeforeOpen) {
+          const canOpen = await options.onBeforeOpen();
+          if (!canOpen) {
+            return;
+          }
+        }
+        ignoreNextDocumentClick = true;
+        openMenu();
+        window.setTimeout(() => {
+          ignoreNextDocumentClick = false;
+        }, 0);
+      })();
+    },
+    { signal }
+  );
+  let ignoreNextDocumentClick = false;
+  const onDocumentClick = (event) => {
+    if (ignoreNextDocumentClick) {
+      return;
+    }
+    if (!wrapper.contains(event.target) && !menu.contains(event.target)) {
+      closeMenu();
+    }
+  };
+  const onReposition = () => {
+    if (!menu.hidden) {
+      positionMenu(trigger, menu);
+    }
+  };
+  document.addEventListener(
+    "click",
+    (event) => {
+      if (menu.hidden) {
+        return;
+      }
+      onDocumentClick(event);
+    },
+    { signal }
+  );
+  document.addEventListener("scroll", onReposition, { capture: true, signal });
+  window.addEventListener("resize", onReposition, { signal });
+  document.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.key === "Escape" && !menu.hidden) {
+        closeMenu();
+      }
+    },
+    { signal }
+  );
+  signal.addEventListener("abort", () => {
+    if (!menu.hidden) {
+      openInsertMenuCount = Math.max(0, openInsertMenuCount - 1);
+    }
+    menu.remove();
+  });
+  wrapper.append(trigger);
+  return { wrapper, menu };
+}
+const CLIPBOARD_PLUGIN_ID = PLUGIN_ID;
+const CLIPBOARD_VERSION = 1;
+let memoryFallback = null;
+const listeners = /* @__PURE__ */ new Set();
+function notifyListeners() {
+  listeners.forEach((listener) => listener());
+}
+function subscribeClipboard(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function getMemoryClipboardPayload() {
+  return memoryFallback;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseClipboardPayload(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (!isPlainObject(parsed)) {
+      return null;
+    }
+    if (parsed.plugin !== CLIPBOARD_PLUGIN_ID || parsed.version !== CLIPBOARD_VERSION) {
+      return null;
+    }
+    if (!Array.isArray(parsed.entries) || parsed.entries.length === 0) {
+      return null;
+    }
+    const validEntries = parsed.entries.every(
+      (entry) => isPlainObject(entry) && typeof entry.__component === "string"
+    );
+    if (!validEntries) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function buildClipboardPayload(entries) {
+  return {
+    plugin: CLIPBOARD_PLUGIN_ID,
+    version: CLIPBOARD_VERSION,
+    entries,
+    source: {
+      copiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      components: entries.map((entry) => entry.__component).filter(Boolean)
+    }
+  };
+}
+async function writeClipboardPayload(payload) {
+  memoryFallback = payload;
+  notifyListeners();
+  const serialized = JSON.stringify(payload);
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    try {
+      await navigator.clipboard.writeText(serialized);
+    } catch {
+    }
+  }
+}
+async function resolveClipboardPayload() {
+  return getMemoryClipboardPayload() ?? await readClipboardPayload();
+}
+async function readClipboardPayload() {
+  if (memoryFallback) {
+    return memoryFallback;
+  }
+  if (typeof navigator !== "undefined" && navigator.clipboard?.readText) {
+    try {
+      const text = await navigator.clipboard.readText();
+      const parsed = parseClipboardPayload(text);
+      if (parsed) {
+        memoryFallback = parsed;
+        notifyListeners();
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function isClipboardCompatibleWithZone(payload, allowedComponents) {
+  if (!payload || payload.entries.length === 0) {
+    return false;
+  }
+  if (!Array.isArray(allowedComponents)) {
+    return true;
+  }
+  return payload.entries.every((entry) => allowedComponents.includes(entry.__component));
+}
+function getRelationQueryParams(query) {
+  if (!query) {
+    return {};
+  }
+  const { plugins, ...rest } = query;
+  const pluginParams = Object.values(plugins ?? {}).reduce(
+    (acc, current) => Object.assign(acc, current),
+    {}
+  );
+  const params = { ...rest, ...pluginParams };
+  return {
+    locale: params.locale,
+    status: params.status
+  };
+}
+const ROW_ACTIONS_ATTR = "data-dz-tools-row-actions";
+const DynamicZoneComponentDuplicateInjector = () => {
+  const { formatMessage } = useIntl();
+  const { get } = useFetchClient();
+  const { toggleNotification } = useNotification();
+  const [{ query }] = useQueryParams();
+  const { form, contentTypes, contentType } = unstable_useContentManagerContext();
+  const contentManagerForm = form;
+  const addFieldRow = contentManagerForm?.addFieldRow;
+  const moveFieldRow = contentManagerForm?.moveFieldRow;
+  const formValues = contentManagerForm?.values ?? {};
+  const valuesRef = React.useRef(formValues);
+  const schemasRef = React.useRef(null);
+  const fetchRelationItemsRef = React.useRef(null);
+  const mountedButtonsRef = React.useRef([]);
+  const frameRef = React.useRef(0);
+  const observerRef = React.useRef(null);
+  const clipboardReadyRef = React.useRef(Boolean(getMemoryClipboardPayload()));
+  const [schemasReady, setSchemasReady] = React.useState(false);
+  const [clipboardTick, setClipboardTick] = React.useState(0);
+  valuesRef.current = formValues;
+  const relationQueryParams = React.useMemo(
+    () => getRelationQueryParams(query),
+    [query]
+  );
+  React.useEffect(() => {
+    fetchRelationItemsRef.current = createFetchRelationItems(get, relationQueryParams);
+  }, [get, relationQueryParams]);
+  React.useEffect(() => {
+    return subscribeClipboard(() => {
+      clipboardReadyRef.current = Boolean(getMemoryClipboardPayload());
+      setClipboardTick((value) => value + 1);
+    });
+  }, []);
+  React.useEffect(() => {
+    const syncClipboardFromSystem = () => {
+      void resolveClipboardPayload().then((payload) => {
+        if (payload) {
+          setClipboardTick((value) => value + 1);
+        }
+      });
+    };
+    window.addEventListener("focus", syncClipboardFromSystem);
+    return () => {
+      window.removeEventListener("focus", syncClipboardFromSystem);
+    };
+  }, []);
+  const duplicateLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-duplicate.action`,
+    defaultMessage: "Duplicate component"
+  });
+  const copyLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-copy.action`,
+    defaultMessage: "Copy block"
+  });
+  const insertLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-insert.menu`,
+    defaultMessage: "Insert"
+  });
+  const pasteAboveLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-paste.above`,
+    defaultMessage: "Paste above"
+  });
+  const pasteBelowLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-paste.below`,
+    defaultMessage: "Paste below"
+  });
+  const pasteUnavailableLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-paste.unavailable`,
+    defaultMessage: "No compatible copied block found. Copy a block first."
+  });
+  const duplicateSuccessLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-duplicate.success`,
+    defaultMessage: "Component duplicated. Save the document to keep it."
+  });
+  const copySuccessLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-copy.success`,
+    defaultMessage: "Block copied."
+  });
+  const pasteSuccessLabels = React.useMemo(
+    () => ({
+      above: formatMessage({
+        id: `${PLUGIN_ID}.component-paste.success.above`,
+        defaultMessage: "Block pasted above. Save the document to keep it."
+      }),
+      below: formatMessage({
+        id: `${PLUGIN_ID}.component-paste.success.below`,
+        defaultMessage: "Block pasted below. Save the document to keep it."
+      })
+    }),
+    [formatMessage]
+  );
+  const pasteErrorLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-paste.error`,
+    defaultMessage: "Could not paste the copied block."
+  });
+  const duplicateErrorLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-duplicate.error`,
+    defaultMessage: "Could not duplicate this component."
+  });
+  const copyErrorLabel = formatMessage({
+    id: `${PLUGIN_ID}.component-copy.error`,
+    defaultMessage: "Could not copy this block."
+  });
+  React.useEffect(() => {
+    let active = true;
+    const fetchSchemas = async () => {
+      try {
+        schemasRef.current = await loadComponentSchemas(get);
+        if (active) {
+          setSchemasReady(true);
+        }
+      } catch {
+        if (active) {
+          setSchemasReady(false);
+        }
+      }
+    };
+    void fetchSchemas();
+    return () => {
+      active = false;
+    };
+  }, [get]);
+  const cleanupMountedButtons = React.useCallback(() => {
+    for (const mounted of mountedButtonsRef.current) {
+      mounted.abort.abort();
+      mounted.menu?.remove();
+      mounted.host.remove();
+    }
+    mountedButtonsRef.current = [];
+  }, []);
+  const getAllowedComponents = React.useCallback(
+    (zonePath) => {
+      const schema = contentType;
+      return schema?.attributes?.[zonePath]?.components;
+    },
+    [contentType]
+  );
+  const insertEntryAt = React.useCallback(
+    (zonePath, targetIndex, entry) => {
+      const zone = valuesRef.current[zonePath];
+      if (!Array.isArray(zone) || typeof addFieldRow !== "function") {
+        return false;
+      }
+      const appendedIndex = zone.length;
+      addFieldRow(zonePath, entry);
+      if (appendedIndex !== targetIndex && typeof moveFieldRow === "function") {
+        moveFieldRow(zonePath, appendedIndex, targetIndex);
+      }
+      return true;
+    },
+    [addFieldRow, moveFieldRow]
+  );
+  const insertEntryBelow = React.useCallback(
+    (zonePath, sourceIndex, entry) => insertEntryAt(zonePath, sourceIndex + 1, entry),
+    [insertEntryAt]
+  );
+  const ensurePasteAvailable = React.useCallback(
+    async (zonePath) => {
+      const payload = await resolveClipboardPayload();
+      const allowedComponents = getAllowedComponents(zonePath);
+      const compatible = isClipboardCompatibleWithZone(payload, allowedComponents);
+      if (compatible) {
+        return true;
+      }
+      toggleNotification({ type: "warning", message: pasteUnavailableLabel });
+      return false;
+    },
+    [getAllowedComponents, pasteUnavailableLabel, toggleNotification]
+  );
+  const handleDuplicate = React.useCallback(
+    async (zonePath, sourceIndex) => {
+      const schemas = schemasRef.current;
+      if (!schemas || typeof addFieldRow !== "function") {
+        toggleNotification({ type: "danger", message: duplicateErrorLabel });
+        return;
+      }
+      const zone = valuesRef.current[zonePath];
+      if (!Array.isArray(zone) || !zone[sourceIndex]) {
+        toggleNotification({ type: "danger", message: duplicateErrorLabel });
+        return;
+      }
+      try {
+        const clonedEntry = await cloneFormDynamicZoneEntry(zone[sourceIndex], {
+          schemas,
+          contentTypes,
+          fetchRelationItems: fetchRelationItemsRef.current ?? void 0
+        });
+        if (!insertEntryBelow(zonePath, sourceIndex, clonedEntry)) {
+          throw new Error("Insert failed");
+        }
+        toggleNotification({
+          type: "success",
+          message: duplicateSuccessLabel
+        });
+      } catch {
+        toggleNotification({ type: "danger", message: duplicateErrorLabel });
+      }
+    },
+    [
+      contentTypes,
+      duplicateErrorLabel,
+      duplicateSuccessLabel,
+      insertEntryBelow,
+      toggleNotification
+    ]
+  );
+  const handleCopy = React.useCallback(
+    async (zonePath, sourceIndex) => {
+      const schemas = schemasRef.current;
+      const zone = valuesRef.current[zonePath];
+      if (!schemas || !Array.isArray(zone) || !zone[sourceIndex]) {
+        toggleNotification({ type: "danger", message: copyErrorLabel });
+        return;
+      }
+      try {
+        const clonedEntry = await cloneFormDynamicZoneEntry(zone[sourceIndex], {
+          schemas,
+          contentTypes,
+          fetchRelationItems: fetchRelationItemsRef.current ?? void 0
+        });
+        const payload = buildClipboardPayload([clonedEntry]);
+        await writeClipboardPayload(payload);
+        clipboardReadyRef.current = true;
+        setClipboardTick((value) => value + 1);
+        toggleNotification({
+          type: "success",
+          message: copySuccessLabel
+        });
+      } catch {
+        toggleNotification({ type: "danger", message: copyErrorLabel });
+      }
+    },
+    [contentTypes, copyErrorLabel, copySuccessLabel, toggleNotification]
+  );
+  const handlePaste = React.useCallback(
+    async (zonePath, sourceIndex, position) => {
+      if (typeof addFieldRow !== "function") {
+        toggleNotification({ type: "danger", message: pasteErrorLabel });
+        return;
+      }
+      try {
+        const payload = await resolveClipboardPayload();
+        const allowedComponents = getAllowedComponents(zonePath);
+        if (!isClipboardCompatibleWithZone(payload, allowedComponents)) {
+          toggleNotification({ type: "danger", message: pasteErrorLabel });
+          return;
+        }
+        let insertIndex = sourceIndex;
+        const zone = valuesRef.current[zonePath];
+        if (!Array.isArray(zone)) {
+          throw new Error("Zone not found");
+        }
+        for (const entry of payload.entries) {
+          let inserted = false;
+          let preparedEntry = entry;
+          if (position === "above") {
+            preparedEntry = prepareEntryForZoneInsert(zone, insertIndex, entry);
+            inserted = insertEntryAt(zonePath, insertIndex, preparedEntry);
+            insertIndex += 1;
+          } else {
+            preparedEntry = prepareEntryForZoneInsert(zone, insertIndex + 1, entry);
+            inserted = insertEntryBelow(zonePath, insertIndex, preparedEntry);
+            insertIndex += 1;
+          }
+          if (!inserted) {
+            throw new Error("Insert failed");
+          }
+        }
+        toggleNotification({
+          type: "success",
+          message: pasteSuccessLabels[position]
+        });
+      } catch {
+        toggleNotification({ type: "danger", message: pasteErrorLabel });
+      }
+    },
+    [
+      addFieldRow,
+      getAllowedComponents,
+      insertEntryAt,
+      insertEntryBelow,
+      pasteErrorLabel,
+      pasteSuccessLabels,
+      toggleNotification
+    ]
+  );
+  const mountRowActions = React.useCallback(
+    (actionContainer, zonePath, sourceIndex, insertBefore) => {
+      const templateButton = actionContainer.querySelector("button");
+      if (!(templateButton instanceof HTMLButtonElement)) {
+        return;
+      }
+      const host = document.createElement("span");
+      host.setAttribute(ROW_ACTIONS_ATTR, "true");
+      host.style.display = "inline-flex";
+      host.style.gap = "0";
+      const abort = new AbortController();
+      host.appendChild(
+        createRowActionButton(
+          templateButton,
+          duplicateLabel,
+          DUPLICATE_ICON_PATH,
+          () => {
+            void handleDuplicate(zonePath, sourceIndex);
+          },
+          abort.signal
+        )
+      );
+      host.appendChild(
+        createRowActionButton(
+          templateButton,
+          copyLabel,
+          COPY_BLOCK_ICON_PATH,
+          () => {
+            void handleCopy(zonePath, sourceIndex);
+          },
+          abort.signal
+        )
+      );
+      const { wrapper: insertMenu, menu } = createRowActionMenu(
+        templateButton,
+        insertLabel,
+        [
+          {
+            label: pasteAboveLabel,
+            onSelect: () => {
+              void handlePaste(zonePath, sourceIndex, "above");
+            }
+          },
+          {
+            label: pasteBelowLabel,
+            onSelect: () => {
+              void handlePaste(zonePath, sourceIndex, "below");
+            }
+          }
+        ],
+        abort.signal,
+        {
+          onBeforeOpen: () => ensurePasteAvailable(zonePath)
+        }
+      );
+      host.appendChild(insertMenu);
+      mountedButtonsRef.current.push({ host, menu, abort });
+      if (insertBefore) {
+        actionContainer.insertBefore(host, insertBefore);
+      } else {
+        actionContainer.appendChild(host);
+      }
+      return;
+    },
+    [
+      copyLabel,
+      duplicateLabel,
+      ensurePasteAvailable,
+      handleCopy,
+      handleDuplicate,
+      handlePaste,
+      insertLabel,
+      pasteAboveLabel,
+      pasteBelowLabel
+    ]
+  );
+  const mountForRow = React.useCallback(
+    (rowElement, blockRef) => {
+      const actionContainer = findRowActionContainer(rowElement);
+      if (!(actionContainer instanceof HTMLElement) || actionContainer.querySelector(`[${ROW_ACTIONS_ATTR}]`)) {
+        return;
+      }
+      mountRowActions(
+        actionContainer,
+        blockRef.zonePath,
+        blockRef.index,
+        getRowActionInsertPoint(actionContainer)
+      );
+    },
+    [mountRowActions]
+  );
+  const syncDuplicateButtons = React.useCallback(() => {
+    const observer = observerRef.current;
+    if (observer) {
+      observer.disconnect();
+    }
+    cleanupMountedButtons();
+    const currentValues = valuesRef.current;
+    const zonePaths = getDynamicZonePathsFromValues(currentValues);
+    if (!schemasReady || zonePaths.length === 0 || typeof addFieldRow !== "function") {
+      observer?.observe(document.body, { childList: true, subtree: true });
+      return;
+    }
+    for (const list of findDynamicZoneLists()) {
+      const rows = getDynamicZoneListItems(list);
+      rows.forEach((row, index2) => {
+        const blockRef = resolveBlockFromListItem(row, currentValues) ?? resolveBlockFromListItemIndex(list, index2, currentValues, zonePaths);
+        if (!blockRef) {
+          return;
+        }
+        mountForRow(row, blockRef);
+      });
+    }
+    for (const dragHandle of findDynamicZoneDragHandles()) {
+      const rowElement = findRowElementForDragHandle(dragHandle);
+      if (!rowElement || rowElement.querySelector(`[${ROW_ACTIONS_ATTR}]`)) {
+        continue;
+      }
+      const blockRef = resolveBlockFromListItem(rowElement, currentValues);
+      if (blockRef) {
+        mountForRow(rowElement, blockRef);
+      }
+    }
+    observer?.observe(document.body, { childList: true, subtree: true });
+  }, [addFieldRow, cleanupMountedButtons, clipboardTick, mountForRow, schemasReady]);
+  React.useEffect(() => {
+    if (typeof document === "undefined") {
+      return void 0;
+    }
+    const observer = new MutationObserver(() => {
+      if (getOpenInsertMenuCount() > 0) {
+        return;
+      }
+      cancelAnimationFrame(frameRef.current);
+      frameRef.current = requestAnimationFrame(() => {
+        if (getOpenInsertMenuCount() > 0) {
+          return;
+        }
+        syncDuplicateButtons();
+      });
+    });
+    observerRef.current = observer;
+    syncDuplicateButtons();
+    return () => {
+      cancelAnimationFrame(frameRef.current);
+      observer.disconnect();
+      observerRef.current = null;
+      cleanupMountedButtons();
+    };
+  }, [cleanupMountedButtons, syncDuplicateButtons, clipboardTick]);
+  return null;
+};
+const DynamicZoneEditViewExtensions = () => /* @__PURE__ */ jsx(DynamicZoneComponentDuplicateInjector, {});
+const index = {
+  register(app) {
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  async bootstrap(app) {
+    try {
+      const contentManager = app.getPlugin("content-manager");
+      contentManager.apis.addDocumentHeaderAction([DynamicZoneToolsHeaderAction]);
+      const injector = {
+        name: `${PLUGIN_ID}-edit-view-extensions`,
+        Component: DynamicZoneEditViewExtensions
+      };
+      if (typeof contentManager?.injectComponent === "function") {
+        contentManager.injectComponent("editView", "right-links", injector);
+      } else if (typeof app?.injectComponent === "function") {
+        app.injectComponent("editView", "right-links", injector);
+      }
+    } catch (error) {
+      console.warn("Failed to register dynamic zone tools admin extensions:", error);
+    }
+  },
+  async registerTrads(app) {
+    const { locales } = app;
+    const importedTranslations = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => import("./en-DrSdJbJW.mjs") }), `./translations/${locale}.json`, 3).then(({ default: data }) => {
+          return {
+            data: getTranslation(data),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return importedTranslations;
+  }
+};
+export {
+  index as default
+};