@strapi/content-manager 0.0.0-experimental.ae2010c73ea60e398b726874a9b7b2bf3faada51 → 0.0.0-experimental.ae51b136d065d25740e6d2aa634b3dfec5824476

package/dist/admin/preview/utils/fieldUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldUtils.js","sources":["../../../../admin/src/preview/utils/fieldUtils.ts"],"sourcesContent":["import { type FieldContentSourceMap } from '@strapi/admin/strapi-admin';\n\nimport type { PreviewContextValue } from '../pages/Preview';\nimport type { Modules, Schema, Struct, UID } from '@strapi/types';\n\ntype PathPart = { name: string; index?: number };\n\n// Helper function to parse path with array indices and return clean attribute names\nexport const parsePathWithIndices = (path: string): PathPart[] => {\n  // Split by dots, then parse array indices from each part. For example:\n  // input \"components.4.field.relations.2.name\"\n  // output [{name: \"components\", index: 4}, {name: \"field\"}, {name: \"relations\", index: 2}, {name: \"name\"}]\n  return path\n    .split('.')\n    .map((part) => {\n      const numericIndex = parseInt(part, 10);\n      if (!isNaN(numericIndex) && part === numericIndex.toString()) {\n        // This part is a pure numeric index, return it as an index for the previous part\n        return { name: '', index: numericIndex };\n      }\n      return { name: part };\n    })\n    .reduce((acc: PathPart[], part, index, array) => {\n      if (part.name === '' && part.index !== undefined) {\n        // This is an index, attach it to the previous part\n        if (acc.length > 0) {\n          acc[acc.length - 1].index = part.index;\n        }\n      } else {\n        acc.push(part);\n      }\n      return acc;\n    }, []);\n};\n\nexport function getAttributeSchemaFromPath({\n  path,\n  schema,\n  components,\n  document,\n}: {\n  path: string;\n  schema: PreviewContextValue['schema'] | PreviewContextValue['components'][string];\n  components: PreviewContextValue['components'];\n  document: Modules.Documents.AnyDocument;\n}): Schema.Attribute.AnyAttribute {\n  /**\n   * Create the function that will be recursively called.\n   * We don't do recursion on getAttributeSchemaFromPath itself because:\n   * - it takes a path string, not the parsed array that's better for recursion\n   * - even when several levels deep, we still need access to the root schema and components\n   */\n  const visitor = (\n    currentPathParts: PathPart[],\n    currentAttributes: Schema.Attributes,\n    currentData: any\n  ): Schema.Attribute.AnyAttribute => {\n    const [currentPart, ...remainingParts] = currentPathParts;\n\n    // Get the data and schema for the current path\n    const currentAttribute = currentAttributes[currentPart.name];\n\n    if (!currentAttribute) {\n      throw new Error('Invalid field path');\n    }\n\n    if (currentAttribute.type === 'relation') {\n      throw new Error('Relations not handled');\n    }\n\n    if (currentAttribute.type === 'component') {\n      const componentAttributes = components[currentAttribute.component].attributes;\n      if (currentAttribute.repeatable) {\n        // We must have the index, otherwise we don't know what data to use\n        if (currentPart.index === undefined) {\n          throw new Error('Invalid field path');\n        }\n        return visitor(\n          remainingParts,\n          componentAttributes,\n          currentData[currentPart.name][currentPart.index]\n        );\n      }\n\n      // Non repeatable component\n      return visitor(remainingParts, componentAttributes, currentData[currentPart.name]);\n    }\n\n    if (currentAttribute.type === 'dynamiczone') {\n      // We must have the index, otherwise we don't know what component we're dealing with\n      if (currentPart.index === undefined) {\n        throw new Error('Invalid field path');\n      }\n\n      const componentData = currentData[currentPart.name][currentPart.index];\n      const componentAttributes = components[componentData.__component].attributes;\n      return visitor(remainingParts, componentAttributes, componentData);\n    }\n\n    // Plain regular field. It ends the recursion\n    return currentAttributes[currentPart.name];\n  };\n\n  return visitor(parsePathWithIndices(path), schema.attributes, document);\n}\n\nexport function parseFieldMetaData(strapiSource: string): FieldContentSourceMap | null {\n  const url = new URL(strapiSource);\n  const path = url.searchParams.get('path');\n  const type = url.searchParams.get('type');\n  const documentId = url.searchParams.get('documentId');\n  const locale = url.searchParams.get('locale');\n  const model = url.searchParams.get('model');\n  const kind = url.searchParams.get('kind');\n\n  if (!path || !type || !documentId || !model) {\n    return null;\n  }\n\n  return {\n    path,\n    type: type as Schema.Attribute.AnyAttribute['type'],\n    documentId,\n    locale: locale ?? null,\n    model: model as UID.Schema | undefined,\n    kind: kind as Struct.ContentTypeKind | undefined,\n  };\n}\n"],"names":["parsePathWithIndices","path","split","map","part","numericIndex","parseInt","isNaN","toString","name","index","reduce","acc","array","undefined","length","push","getAttributeSchemaFromPath","schema","components","document","visitor","currentPathParts","currentAttributes","currentData","currentPart","remainingParts","currentAttribute","Error","type","componentAttributes","component","attributes","repeatable","componentData","__component","parseFieldMetaData","strapiSource","url","URL","searchParams","get","documentId","locale","model","kind"],"mappings":"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"}

package/dist/admin/preview/utils/fieldUtils.mjs

@@ -0,0 +1,94 @@
+// Helper function to parse path with array indices and return clean attribute names
+const parsePathWithIndices = (path)=>{
+    // Split by dots, then parse array indices from each part. For example:
+    // input "components.4.field.relations.2.name"
+    // output [{name: "components", index: 4}, {name: "field"}, {name: "relations", index: 2}, {name: "name"}]
+    return path.split('.').map((part)=>{
+        const numericIndex = parseInt(part, 10);
+        if (!isNaN(numericIndex) && part === numericIndex.toString()) {
+            // This part is a pure numeric index, return it as an index for the previous part
+            return {
+                name: '',
+                index: numericIndex
+            };
+        }
+        return {
+            name: part
+        };
+    }).reduce((acc, part, index, array)=>{
+        if (part.name === '' && part.index !== undefined) {
+            // This is an index, attach it to the previous part
+            if (acc.length > 0) {
+                acc[acc.length - 1].index = part.index;
+            }
+        } else {
+            acc.push(part);
+        }
+        return acc;
+    }, []);
+};
+function getAttributeSchemaFromPath({ path, schema, components, document }) {
+    /**
+   * Create the function that will be recursively called.
+   * We don't do recursion on getAttributeSchemaFromPath itself because:
+   * - it takes a path string, not the parsed array that's better for recursion
+   * - even when several levels deep, we still need access to the root schema and components
+   */ const visitor = (currentPathParts, currentAttributes, currentData)=>{
+        const [currentPart, ...remainingParts] = currentPathParts;
+        // Get the data and schema for the current path
+        const currentAttribute = currentAttributes[currentPart.name];
+        if (!currentAttribute) {
+            throw new Error('Invalid field path');
+        }
+        if (currentAttribute.type === 'relation') {
+            throw new Error('Relations not handled');
+        }
+        if (currentAttribute.type === 'component') {
+            const componentAttributes = components[currentAttribute.component].attributes;
+            if (currentAttribute.repeatable) {
+                // We must have the index, otherwise we don't know what data to use
+                if (currentPart.index === undefined) {
+                    throw new Error('Invalid field path');
+                }
+                return visitor(remainingParts, componentAttributes, currentData[currentPart.name][currentPart.index]);
+            }
+            // Non repeatable component
+            return visitor(remainingParts, componentAttributes, currentData[currentPart.name]);
+        }
+        if (currentAttribute.type === 'dynamiczone') {
+            // We must have the index, otherwise we don't know what component we're dealing with
+            if (currentPart.index === undefined) {
+                throw new Error('Invalid field path');
+            }
+            const componentData = currentData[currentPart.name][currentPart.index];
+            const componentAttributes = components[componentData.__component].attributes;
+            return visitor(remainingParts, componentAttributes, componentData);
+        }
+        // Plain regular field. It ends the recursion
+        return currentAttributes[currentPart.name];
+    };
+    return visitor(parsePathWithIndices(path), schema.attributes, document);
+}
+function parseFieldMetaData(strapiSource) {
+    const url = new URL(strapiSource);
+    const path = url.searchParams.get('path');
+    const type = url.searchParams.get('type');
+    const documentId = url.searchParams.get('documentId');
+    const locale = url.searchParams.get('locale');
+    const model = url.searchParams.get('model');
+    const kind = url.searchParams.get('kind');
+    if (!path || !type || !documentId || !model) {
+        return null;
+    }
+    return {
+        path,
+        type: type,
+        documentId,
+        locale: locale ?? null,
+        model: model,
+        kind: kind
+    };
+}
+
+export { getAttributeSchemaFromPath, parseFieldMetaData, parsePathWithIndices };
+//# sourceMappingURL=fieldUtils.mjs.map

package/dist/admin/preview/utils/fieldUtils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldUtils.mjs","sources":["../../../../admin/src/preview/utils/fieldUtils.ts"],"sourcesContent":["import { type FieldContentSourceMap } from '@strapi/admin/strapi-admin';\n\nimport type { PreviewContextValue } from '../pages/Preview';\nimport type { Modules, Schema, Struct, UID } from '@strapi/types';\n\ntype PathPart = { name: string; index?: number };\n\n// Helper function to parse path with array indices and return clean attribute names\nexport const parsePathWithIndices = (path: string): PathPart[] => {\n  // Split by dots, then parse array indices from each part. For example:\n  // input \"components.4.field.relations.2.name\"\n  // output [{name: \"components\", index: 4}, {name: \"field\"}, {name: \"relations\", index: 2}, {name: \"name\"}]\n  return path\n    .split('.')\n    .map((part) => {\n      const numericIndex = parseInt(part, 10);\n      if (!isNaN(numericIndex) && part === numericIndex.toString()) {\n        // This part is a pure numeric index, return it as an index for the previous part\n        return { name: '', index: numericIndex };\n      }\n      return { name: part };\n    })\n    .reduce((acc: PathPart[], part, index, array) => {\n      if (part.name === '' && part.index !== undefined) {\n        // This is an index, attach it to the previous part\n        if (acc.length > 0) {\n          acc[acc.length - 1].index = part.index;\n        }\n      } else {\n        acc.push(part);\n      }\n      return acc;\n    }, []);\n};\n\nexport function getAttributeSchemaFromPath({\n  path,\n  schema,\n  components,\n  document,\n}: {\n  path: string;\n  schema: PreviewContextValue['schema'] | PreviewContextValue['components'][string];\n  components: PreviewContextValue['components'];\n  document: Modules.Documents.AnyDocument;\n}): Schema.Attribute.AnyAttribute {\n  /**\n   * Create the function that will be recursively called.\n   * We don't do recursion on getAttributeSchemaFromPath itself because:\n   * - it takes a path string, not the parsed array that's better for recursion\n   * - even when several levels deep, we still need access to the root schema and components\n   */\n  const visitor = (\n    currentPathParts: PathPart[],\n    currentAttributes: Schema.Attributes,\n    currentData: any\n  ): Schema.Attribute.AnyAttribute => {\n    const [currentPart, ...remainingParts] = currentPathParts;\n\n    // Get the data and schema for the current path\n    const currentAttribute = currentAttributes[currentPart.name];\n\n    if (!currentAttribute) {\n      throw new Error('Invalid field path');\n    }\n\n    if (currentAttribute.type === 'relation') {\n      throw new Error('Relations not handled');\n    }\n\n    if (currentAttribute.type === 'component') {\n      const componentAttributes = components[currentAttribute.component].attributes;\n      if (currentAttribute.repeatable) {\n        // We must have the index, otherwise we don't know what data to use\n        if (currentPart.index === undefined) {\n          throw new Error('Invalid field path');\n        }\n        return visitor(\n          remainingParts,\n          componentAttributes,\n          currentData[currentPart.name][currentPart.index]\n        );\n      }\n\n      // Non repeatable component\n      return visitor(remainingParts, componentAttributes, currentData[currentPart.name]);\n    }\n\n    if (currentAttribute.type === 'dynamiczone') {\n      // We must have the index, otherwise we don't know what component we're dealing with\n      if (currentPart.index === undefined) {\n        throw new Error('Invalid field path');\n      }\n\n      const componentData = currentData[currentPart.name][currentPart.index];\n      const componentAttributes = components[componentData.__component].attributes;\n      return visitor(remainingParts, componentAttributes, componentData);\n    }\n\n    // Plain regular field. It ends the recursion\n    return currentAttributes[currentPart.name];\n  };\n\n  return visitor(parsePathWithIndices(path), schema.attributes, document);\n}\n\nexport function parseFieldMetaData(strapiSource: string): FieldContentSourceMap | null {\n  const url = new URL(strapiSource);\n  const path = url.searchParams.get('path');\n  const type = url.searchParams.get('type');\n  const documentId = url.searchParams.get('documentId');\n  const locale = url.searchParams.get('locale');\n  const model = url.searchParams.get('model');\n  const kind = url.searchParams.get('kind');\n\n  if (!path || !type || !documentId || !model) {\n    return null;\n  }\n\n  return {\n    path,\n    type: type as Schema.Attribute.AnyAttribute['type'],\n    documentId,\n    locale: locale ?? null,\n    model: model as UID.Schema | undefined,\n    kind: kind as Struct.ContentTypeKind | undefined,\n  };\n}\n"],"names":["parsePathWithIndices","path","split","map","part","numericIndex","parseInt","isNaN","toString","name","index","reduce","acc","array","undefined","length","push","getAttributeSchemaFromPath","schema","components","document","visitor","currentPathParts","currentAttributes","currentData","currentPart","remainingParts","currentAttribute","Error","type","componentAttributes","component","attributes","repeatable","componentData","__component","parseFieldMetaData","strapiSource","url","URL","searchParams","get","documentId","locale","model","kind"],"mappings":"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"}

package/dist/admin/preview/utils/getSendMessage.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * A function factory so we can generate a new sendMessage everytime we need one.
+ * We can't store and reuse a single sendMessage because it needs to have a stable identity
+ * as it used in a useEffect function. And we can't rely on useCallback because we need the
+ * up-to-date iframe ref, and this would make it stale (refs don't trigger callback reevaluations).
+ */ function getSendMessage(iframe) {
+    return (type, payload)=>{
+        if (!iframe?.current) return;
+        const { origin } = new URL(iframe.current.src);
+        iframe.current.contentWindow?.postMessage({
+            type,
+            ...payload !== undefined && {
+                payload
+            }
+        }, origin);
+    };
+}
+
+exports.getSendMessage = getSendMessage;
+//# sourceMappingURL=getSendMessage.js.map

package/dist/admin/preview/utils/getSendMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSendMessage.js","sources":["../../../../admin/src/preview/utils/getSendMessage.ts"],"sourcesContent":["import type { INTERNAL_EVENTS, PUBLIC_EVENTS } from './constants';\n\ntype MessageType =\n  | (typeof INTERNAL_EVENTS)[keyof typeof INTERNAL_EVENTS]\n  | (typeof PUBLIC_EVENTS)[keyof typeof PUBLIC_EVENTS];\n\n/**\n * A function factory so we can generate a new sendMessage everytime we need one.\n * We can't store and reuse a single sendMessage because it needs to have a stable identity\n * as it used in a useEffect function. And we can't rely on useCallback because we need the\n * up-to-date iframe ref, and this would make it stale (refs don't trigger callback reevaluations).\n */\nexport function getSendMessage(iframe: React.RefObject<HTMLIFrameElement> | undefined) {\n  return (type: MessageType, payload?: unknown) => {\n    if (!iframe?.current) return;\n\n    const { origin } = new URL(iframe.current.src);\n\n    iframe.current.contentWindow?.postMessage(\n      {\n        type,\n        ...(payload !== undefined && { payload }),\n      },\n      origin\n    );\n  };\n}\n"],"names":["getSendMessage","iframe","type","payload","current","origin","URL","src","contentWindow","postMessage","undefined"],"mappings":";;AAMA;;;;;IAMO,SAASA,cAAAA,CAAeC,MAAsD,EAAA;AACnF,IAAA,OAAO,CAACC,IAAmBC,EAAAA,OAAAA,GAAAA;QACzB,IAAI,CAACF,QAAQG,OAAS,EAAA;QAEtB,MAAM,EAAEC,MAAM,EAAE,GAAG,IAAIC,GAAIL,CAAAA,MAAAA,CAAOG,OAAO,CAACG,GAAG,CAAA;AAE7CN,QAAAA,MAAAA,CAAOG,OAAO,CAACI,aAAa,EAAEC,WAC5B,CAAA;AACEP,YAAAA,IAAAA;AACA,YAAA,GAAIC,YAAYO,SAAa,IAAA;AAAEP,gBAAAA;;SAEjCE,EAAAA,MAAAA,CAAAA;AAEJ,KAAA;AACF;;;;"}

package/dist/admin/preview/utils/getSendMessage.mjs

@@ -0,0 +1,20 @@
+/**
+ * A function factory so we can generate a new sendMessage everytime we need one.
+ * We can't store and reuse a single sendMessage because it needs to have a stable identity
+ * as it used in a useEffect function. And we can't rely on useCallback because we need the
+ * up-to-date iframe ref, and this would make it stale (refs don't trigger callback reevaluations).
+ */ function getSendMessage(iframe) {
+    return (type, payload)=>{
+        if (!iframe?.current) return;
+        const { origin } = new URL(iframe.current.src);
+        iframe.current.contentWindow?.postMessage({
+            type,
+            ...payload !== undefined && {
+                payload
+            }
+        }, origin);
+    };
+}
+
+export { getSendMessage };
+//# sourceMappingURL=getSendMessage.mjs.map

package/dist/admin/preview/utils/getSendMessage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSendMessage.mjs","sources":["../../../../admin/src/preview/utils/getSendMessage.ts"],"sourcesContent":["import type { INTERNAL_EVENTS, PUBLIC_EVENTS } from './constants';\n\ntype MessageType =\n  | (typeof INTERNAL_EVENTS)[keyof typeof INTERNAL_EVENTS]\n  | (typeof PUBLIC_EVENTS)[keyof typeof PUBLIC_EVENTS];\n\n/**\n * A function factory so we can generate a new sendMessage everytime we need one.\n * We can't store and reuse a single sendMessage because it needs to have a stable identity\n * as it used in a useEffect function. And we can't rely on useCallback because we need the\n * up-to-date iframe ref, and this would make it stale (refs don't trigger callback reevaluations).\n */\nexport function getSendMessage(iframe: React.RefObject<HTMLIFrameElement> | undefined) {\n  return (type: MessageType, payload?: unknown) => {\n    if (!iframe?.current) return;\n\n    const { origin } = new URL(iframe.current.src);\n\n    iframe.current.contentWindow?.postMessage(\n      {\n        type,\n        ...(payload !== undefined && { payload }),\n      },\n      origin\n    );\n  };\n}\n"],"names":["getSendMessage","iframe","type","payload","current","origin","URL","src","contentWindow","postMessage","undefined"],"mappings":"AAMA;;;;;IAMO,SAASA,cAAAA,CAAeC,MAAsD,EAAA;AACnF,IAAA,OAAO,CAACC,IAAmBC,EAAAA,OAAAA,GAAAA;QACzB,IAAI,CAACF,QAAQG,OAAS,EAAA;QAEtB,MAAM,EAAEC,MAAM,EAAE,GAAG,IAAIC,GAAIL,CAAAA,MAAAA,CAAOG,OAAO,CAACG,GAAG,CAAA;AAE7CN,QAAAA,MAAAA,CAAOG,OAAO,CAACI,aAAa,EAAEC,WAC5B,CAAA;AACEP,YAAAA,IAAAA;AACA,YAAA,GAAIC,YAAYO,SAAa,IAAA;AAAEP,gBAAAA;;SAEjCE,EAAAA,MAAAA,CAAAA;AAEJ,KAAA;AACF;;;;"}

package/dist/admin/preview/utils/previewScript.js

@@ -0,0 +1,452 @@
+'use strict';
+
+// NOTE: This override is for the properties on _user's site_, it's not about Strapi Admin.
+/**
+ * previewScript will be injected into the preview iframe after being stringified.
+ * Therefore it CANNOT use any imports, or refer to any variables outside of its own scope.
+ * It's why many functions are defined within previewScript, it's the only way to avoid going full spaghetti.
+ * To get a better overview of everything previewScript does, go to the orchestration part at its end.
+ */ const previewScript = (shouldRun = true)=>{
+    /* -----------------------------------------------------------------------------------------------
+   * Params
+   * ---------------------------------------------------------------------------------------------*/ const HIGHLIGHT_PADDING = 2; // in pixels
+    const HIGHLIGHT_HOVER_COLOR = window.STRAPI_HIGHLIGHT_HOVER_COLOR ?? '#4945ff'; // dark primary500
+    const HIGHLIGHT_ACTIVE_COLOR = window.STRAPI_HIGHLIGHT_ACTIVE_COLOR ?? '#7b79ff'; // dark primary600
+    const DISABLE_STEGA_DECODING = window.STRAPI_DISABLE_STEGA_DECODING ?? false;
+    const SOURCE_ATTRIBUTE = 'data-strapi-source';
+    const OVERLAY_ID = 'strapi-preview-overlay';
+    const INTERNAL_EVENTS = {
+        STRAPI_FIELD_FOCUS: 'strapiFieldFocus',
+        STRAPI_FIELD_BLUR: 'strapiFieldBlur',
+        STRAPI_FIELD_CHANGE: 'strapiFieldChange',
+        STRAPI_FIELD_FOCUS_INTENT: 'strapiFieldFocusIntent'
+    };
+    /**
+   * Calling the function in no-run mode lets us retrieve the constants from other files and keep
+   * a single source of truth for them. It's the only way to do this because this script can't
+   * refer to any variables outside of its own scope, because it's stringified before it's run.
+   */ if (!shouldRun) {
+        return {
+            INTERNAL_EVENTS
+        };
+    }
+    /* -----------------------------------------------------------------------------------------------
+   * Utils
+   * ---------------------------------------------------------------------------------------------*/ const sendMessage = (type, payload)=>{
+        window.parent.postMessage({
+            type,
+            payload
+        }, '*');
+    };
+    const getElementsByPath = (path)=>{
+        return document.querySelectorAll(`[${SOURCE_ATTRIBUTE}*="path=${path}"]`);
+    };
+    /* -----------------------------------------------------------------------------------------------
+   * Functionality pieces
+   * ---------------------------------------------------------------------------------------------*/ const setupStegaDOMObserver = async ()=>{
+        if (DISABLE_STEGA_DECODING) {
+            return;
+        }
+        const { vercelStegaDecode: stegaDecode, vercelStegaClean: stegaClean } = await import(// @ts-expect-error it's not a local dependency
+        // eslint-disable-next-line import/no-unresolved
+        'https://cdn.jsdelivr.net/npm/@vercel/stega@0.1.2/+esm');
+        const processElementForStega = (element)=>{
+            const directTextNodes = Array.from(element.childNodes).filter((node)=>node.nodeType === Node.TEXT_NODE);
+            const directTextContent = directTextNodes.map((node)=>node.textContent || '').join('');
+            if (directTextContent) {
+                try {
+                    const result = stegaDecode(directTextContent);
+                    if (result && 'strapiSource' in result) {
+                        element.setAttribute(SOURCE_ATTRIBUTE, result.strapiSource);
+                        // Remove encoded part from DOM text content (to avoid breaking links for example)
+                        directTextNodes.forEach((node)=>{
+                            if (node.textContent) {
+                                const cleanedText = stegaClean(node.textContent);
+                                if (cleanedText !== node.textContent) {
+                                    node.textContent = cleanedText;
+                                }
+                            }
+                        });
+                    }
+                } catch (error) {}
+            }
+        };
+        // Process all existing elements
+        const allElements = document.querySelectorAll('*');
+        Array.from(allElements).forEach(processElementForStega);
+        // Create observer for new elements and text changes
+        const observer = new MutationObserver((mutations)=>{
+            mutations.forEach((mutation)=>{
+                // Handle added nodes
+                if (mutation.type === 'childList') {
+                    mutation.addedNodes.forEach((node)=>{
+                        if (node.nodeType === Node.ELEMENT_NODE) {
+                            const element = node;
+                            // Process the added element
+                            processElementForStega(element);
+                            // Process all child elements
+                            const childElements = element.querySelectorAll('*');
+                            Array.from(childElements).forEach(processElementForStega);
+                        }
+                    });
+                }
+                // Handle text content changes
+                if (mutation.type === 'characterData' && mutation.target.parentElement) {
+                    processElementForStega(mutation.target.parentElement);
+                }
+            });
+        });
+        observer.observe(document, {
+            childList: true,
+            subtree: true,
+            characterData: true
+        });
+        return observer;
+    };
+    const createOverlaySystem = ()=>{
+        // Clean up before creating a new overlay so we can safely call previewScript multiple times
+        window.__strapi_previewCleanup?.();
+        document.getElementById(OVERLAY_ID)?.remove();
+        const overlay = document.createElement('div');
+        overlay.id = OVERLAY_ID;
+        overlay.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 9999;
+    `;
+        window.document.body.appendChild(overlay);
+        return overlay;
+    };
+    const createHighlightManager = (overlay)=>{
+        const elementToHighlight = new Map();
+        const eventListeners = [];
+        const focusedHighlights = [];
+        let focusedField = null;
+        const drawHighlight = (target, highlight)=>{
+            if (!highlight) return;
+            const rect = target.getBoundingClientRect();
+            highlight.style.width = `${rect.width + HIGHLIGHT_PADDING * 2}px`;
+            highlight.style.height = `${rect.height + HIGHLIGHT_PADDING * 2}px`;
+            highlight.style.transform = `translate(${rect.left - HIGHLIGHT_PADDING}px, ${rect.top - HIGHLIGHT_PADDING}px)`;
+        };
+        const updateAllHighlights = ()=>{
+            elementToHighlight.forEach((highlight, element)=>{
+                drawHighlight(element, highlight);
+            });
+        };
+        const createHighlightForElement = (element)=>{
+            if (elementToHighlight.has(element)) {
+                return; // Already has a highlight
+            }
+            const highlight = document.createElement('div');
+            highlight.style.cssText = `
+        position: absolute;
+        outline: 2px solid transparent;
+        pointer-events: none;
+        border-radius: 2px;
+        background-color: transparent;
+        will-change: transform;
+        transition: outline-color 0.1s ease-in-out;
+      `;
+            // Move hover detection to the underlying element
+            const mouseEnterHandler = ()=>{
+                if (!focusedHighlights.includes(highlight)) {
+                    highlight.style.outlineColor = HIGHLIGHT_HOVER_COLOR;
+                }
+            };
+            const mouseLeaveHandler = ()=>{
+                if (!focusedHighlights.includes(highlight)) {
+                    highlight.style.outlineColor = 'transparent';
+                }
+            };
+            const doubleClickHandler = ()=>{
+                const sourceAttribute = element.getAttribute(SOURCE_ATTRIBUTE);
+                if (sourceAttribute) {
+                    const rect = element.getBoundingClientRect();
+                    sendMessage(INTERNAL_EVENTS.STRAPI_FIELD_FOCUS_INTENT, {
+                        path: sourceAttribute,
+                        position: {
+                            top: rect.top,
+                            left: rect.left,
+                            right: rect.right,
+                            bottom: rect.bottom,
+                            width: rect.width,
+                            height: rect.height
+                        }
+                    });
+                }
+            };
+            const mouseDownHandler = (event)=>{
+                // Prevent default multi click to select behavior
+                if (event.detail >= 2) {
+                    event.preventDefault();
+                }
+            };
+            element.addEventListener('mouseenter', mouseEnterHandler);
+            element.addEventListener('mouseleave', mouseLeaveHandler);
+            element.addEventListener('dblclick', doubleClickHandler);
+            element.addEventListener('mousedown', mouseDownHandler);
+            // Store event listeners for cleanup
+            eventListeners.push({
+                element,
+                type: 'mouseenter',
+                handler: mouseEnterHandler
+            }, {
+                element,
+                type: 'mouseleave',
+                handler: mouseLeaveHandler
+            }, {
+                element,
+                type: 'dblclick',
+                handler: doubleClickHandler
+            }, {
+                element,
+                type: 'mousedown',
+                handler: mouseDownHandler
+            });
+            elementToHighlight.set(element, highlight);
+            overlay.appendChild(highlight);
+            drawHighlight(element, highlight);
+        };
+        const removeHighlightForElement = (element)=>{
+            const highlight = elementToHighlight.get(element);
+            if (!highlight) return;
+            highlight.remove();
+            elementToHighlight.delete(element);
+            // Remove event listeners for this element
+            const listenersToRemove = eventListeners.filter((listener)=>listener.element === element);
+            listenersToRemove.forEach(({ element, type, handler })=>{
+                element.removeEventListener(type, handler);
+            });
+            // Mutate eventListeners to remove listeners for this element
+            eventListeners.splice(0, eventListeners.length, ...eventListeners.filter((listener)=>listener.element !== element));
+        };
+        // Process all existing elements with source attributes
+        const initialElements = window.document.querySelectorAll(`[${SOURCE_ATTRIBUTE}]`);
+        Array.from(initialElements).forEach((element)=>{
+            if (element instanceof HTMLElement) {
+                createHighlightForElement(element);
+            }
+        });
+        return {
+            get elements () {
+                return Array.from(elementToHighlight.keys());
+            },
+            get highlights () {
+                return Array.from(elementToHighlight.values());
+            },
+            updateAllHighlights,
+            eventListeners,
+            focusedHighlights,
+            createHighlightForElement,
+            removeHighlightForElement,
+            setFocusedField: (field)=>{
+                focusedField = field;
+            },
+            getFocusedField: ()=>focusedField
+        };
+    };
+    const setupObservers = (highlightManager, stegaObserver)=>{
+        const resizeObserver = new ResizeObserver(()=>{
+            highlightManager.updateAllHighlights();
+        });
+        const observeElementForResize = (element)=>{
+            resizeObserver.observe(element);
+        };
+        // Observe existing elements
+        highlightManager.elements.forEach(observeElementForResize);
+        resizeObserver.observe(document.documentElement);
+        // Create highlight observer to watch for new elements with source attributes
+        const highlightObserver = new MutationObserver((mutations)=>{
+            mutations.forEach((mutation)=>{
+                if (mutation.type === 'attributes' && mutation.attributeName === SOURCE_ATTRIBUTE) {
+                    const target = mutation.target;
+                    if (target.hasAttribute(SOURCE_ATTRIBUTE)) {
+                        highlightManager.createHighlightForElement(target);
+                        observeElementForResize(target);
+                    } else {
+                        highlightManager.removeHighlightForElement(target);
+                    }
+                }
+                if (mutation.type === 'childList') {
+                    mutation.addedNodes.forEach((node)=>{
+                        if (node.nodeType === Node.ELEMENT_NODE) {
+                            const element = node;
+                            // Check if the added element has source attribute
+                            if (element.hasAttribute(SOURCE_ATTRIBUTE) && element instanceof HTMLElement) {
+                                highlightManager.createHighlightForElement(element);
+                                observeElementForResize(element);
+                            }
+                            // Check all child elements for source attributes
+                            const elementsWithSource = element.querySelectorAll(`[${SOURCE_ATTRIBUTE}]`);
+                            Array.from(elementsWithSource).forEach((childElement)=>{
+                                if (childElement instanceof HTMLElement) {
+                                    highlightManager.createHighlightForElement(childElement);
+                                    observeElementForResize(childElement);
+                                }
+                            });
+                        }
+                    });
+                    mutation.removedNodes.forEach((node)=>{
+                        if (node.nodeType === Node.ELEMENT_NODE) {
+                            const element = node;
+                            highlightManager.removeHighlightForElement(element);
+                        }
+                    });
+                }
+            });
+        });
+        highlightObserver.observe(document, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            attributeFilter: [
+                SOURCE_ATTRIBUTE
+            ]
+        });
+        const updateOnScroll = ()=>{
+            highlightManager.updateAllHighlights();
+        };
+        const scrollableElements = new Set();
+        scrollableElements.add(window);
+        const findScrollableAncestors = ()=>{
+            // Clear existing scrollable elements (except window)
+            scrollableElements.forEach((element)=>{
+                if (element !== window) {
+                    element.removeEventListener('scroll', updateOnScroll);
+                }
+            });
+            scrollableElements.clear();
+            scrollableElements.add(window);
+            // Find all scrollable ancestors for all tracked elements
+            highlightManager.elements.forEach((element)=>{
+                let parent = element.parentElement;
+                while(parent){
+                    const computedStyle = window.getComputedStyle(parent);
+                    const overflow = computedStyle.overflow + computedStyle.overflowX + computedStyle.overflowY;
+                    if (overflow.includes('scroll') || overflow.includes('auto')) {
+                        scrollableElements.add(parent);
+                    }
+                    parent = parent.parentElement;
+                }
+            });
+            // Add scroll listeners to all scrollable elements
+            scrollableElements.forEach((element)=>{
+                if (element === window) {
+                    window.addEventListener('scroll', updateOnScroll);
+                    window.addEventListener('resize', updateOnScroll);
+                } else {
+                    element.addEventListener('scroll', updateOnScroll);
+                }
+            });
+        };
+        // Initial setup of scrollable elements
+        findScrollableAncestors();
+        return {
+            resizeObserver,
+            highlightObserver,
+            stegaObserver,
+            updateOnScroll,
+            scrollableElements,
+            findScrollableAncestors
+        };
+    };
+    const setupEventHandlers = (highlightManager)=>{
+        const handleMessage = (event)=>{
+            if (!event.data?.type) return;
+            // The user typed in an input, reflect the change in the preview
+            if (event.data.type === INTERNAL_EVENTS.STRAPI_FIELD_CHANGE) {
+                const { field, value } = event.data.payload;
+                if (!field) return;
+                getElementsByPath(field).forEach((element)=>{
+                    if (element instanceof HTMLElement) {
+                        element.textContent = value || '';
+                    }
+                });
+                // Update highlight dimensions since the new text content may affect them
+                highlightManager.updateAllHighlights();
+                return;
+            }
+            // The user focused a new input, update the highlights in the preview
+            if (event.data.type === INTERNAL_EVENTS.STRAPI_FIELD_FOCUS) {
+                const { field } = event.data.payload;
+                if (!field) return;
+                // Clear existing focused highlights
+                highlightManager.focusedHighlights.forEach((highlight)=>{
+                    highlight.style.outlineColor = 'transparent';
+                });
+                highlightManager.focusedHighlights.length = 0;
+                // Set new focused field and highlight matching elements
+                highlightManager.setFocusedField(field);
+                getElementsByPath(field).forEach((element)=>{
+                    const highlight = highlightManager.highlights[Array.from(highlightManager.elements).indexOf(element)];
+                    if (highlight) {
+                        highlight.style.outlineColor = HIGHLIGHT_ACTIVE_COLOR;
+                        highlight.style.outlineWidth = '3px';
+                        highlightManager.focusedHighlights.push(highlight);
+                    }
+                });
+                return;
+            }
+            // The user is no longer focusing an input, remove the highlights
+            if (event.data.type === INTERNAL_EVENTS.STRAPI_FIELD_BLUR) {
+                const { field } = event.data.payload;
+                if (field !== highlightManager.getFocusedField()) return;
+                highlightManager.focusedHighlights.forEach((highlight)=>{
+                    highlight.style.outlineColor = 'transparent';
+                    highlight.style.outlineWidth = '2px';
+                });
+                highlightManager.focusedHighlights.length = 0;
+                highlightManager.setFocusedField(null);
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        // Add the message handler to the cleanup list
+        const messageEventListener = {
+            element: window,
+            type: 'message',
+            handler: handleMessage
+        };
+        return [
+            ...highlightManager.eventListeners,
+            messageEventListener
+        ];
+    };
+    const createCleanupSystem = (overlay, observers, eventHandlers)=>{
+        window.__strapi_previewCleanup = ()=>{
+            observers.resizeObserver.disconnect();
+            observers.highlightObserver.disconnect();
+            observers.stegaObserver?.disconnect();
+            // Remove all scroll listeners
+            observers.scrollableElements.forEach((element)=>{
+                if (element === window) {
+                    window.removeEventListener('scroll', observers.updateOnScroll);
+                    window.removeEventListener('resize', observers.updateOnScroll);
+                } else {
+                    element.removeEventListener('scroll', observers.updateOnScroll);
+                }
+            });
+            // Remove highlight event listeners
+            eventHandlers.forEach(({ element, type, handler })=>{
+                element.removeEventListener(type, handler);
+            });
+            overlay.remove();
+        };
+    };
+    /* -----------------------------------------------------------------------------------------------
+   * Orchestration
+   * ---------------------------------------------------------------------------------------------*/ setupStegaDOMObserver().then((stegaObserver)=>{
+        const overlay = createOverlaySystem();
+        const highlightManager = createHighlightManager(overlay);
+        const observers = setupObservers(highlightManager, stegaObserver);
+        const eventHandlers = setupEventHandlers(highlightManager);
+        createCleanupSystem(overlay, observers, eventHandlers);
+    });
+};
+
+exports.previewScript = previewScript;
+//# sourceMappingURL=previewScript.js.map