@contentful/experiences-visual-editor-react 3.7.0-dev-20250919T0822-6a47406.0 → 3.7.0-dev-20250919T1400-8d76591.0

package/dist/renderApp.js

@@ -37,8 +37,8 @@ function styleInject(css, ref) {
   }
 }
 
-var css_248z$a = "html,\nbody {\n  margin: 0;\n  padding: 0;\n}\n\n/*\n * All of these variables are tokens from Forma-36 and should not be adjusted as these\n * are global variables that may affect multiple places.\n * As our customers may use other design libraries, we try to avoid overlapping global\n * variables by always using the prefix `--exp-builder-` inside this SDK.\n */\n\n:root {\n  /* Color tokens from Forma 36: https://f36.contentful.com/tokens/color-system */\n  --exp-builder-blue100: #e8f5ff;\n  --exp-builder-blue200: #ceecff;\n  --exp-builder-blue300: #98cbff;\n  --exp-builder-blue400: #40a0ff;\n  --exp-builder-blue500: #036fe3;\n  --exp-builder-blue600: #0059c8;\n  --exp-builder-blue700: #0041ab;\n  --exp-builder-blue800: #003298;\n  --exp-builder-blue900: #002a8e;\n  --exp-builder-gray100: #f7f9fa;\n  --exp-builder-gray200: #e7ebee;\n  --exp-builder-gray300: #cfd9e0;\n  --exp-builder-gray400: #aec1cc;\n  --exp-builder-gray500: #67728a;\n  --exp-builder-gray600: #5a657c;\n  --exp-builder-gray700: #414d63;\n  --exp-builder-gray800: #1b273a;\n  --exp-builder-gray900: #111b2b;\n  --exp-builder-purple600: #6c3ecf;\n  --exp-builder-red200: #ffe0e0;\n  --exp-builder-red800: #7f0010;\n  --exp-builder-color-white: #ffffff;\n  --exp-builder-glow-primary: 0px 0px 0px 3px #e8f5ff;\n\n  /* RGB colors for applying opacity */\n  --exp-builder-blue100-rgb: 232, 245, 255;\n  --exp-builder-blue300-rgb: 152, 203, 255;\n\n  /* Spacing tokens from Forma 36: https://f36.contentful.com/tokens/spacing */\n  --exp-builder-spacing-s: 0.75rem;\n  --exp-builder-spacing-2xs: 0.25rem;\n\n  /* Typography tokens from Forma 36: https://f36.contentful.com/tokens/typography */\n  --exp-builder-font-size-l: 1rem;\n  --exp-builder-font-size-m: 0.875rem;\n  --exp-builder-font-stack-primary: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial,\n    sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol;\n  --exp-builder-line-height-condensed: 1.25;\n}\n";
-styleInject(css_248z$a);
+var css_248z$b = "html,\nbody {\n  margin: 0;\n  padding: 0;\n}\n\n/*\n * All of these variables are tokens from Forma-36 and should not be adjusted as these\n * are global variables that may affect multiple places.\n * As our customers may use other design libraries, we try to avoid overlapping global\n * variables by always using the prefix `--exp-builder-` inside this SDK.\n */\n\n:root {\n  /* Color tokens from Forma 36: https://f36.contentful.com/tokens/color-system */\n  --exp-builder-blue100: #e8f5ff;\n  --exp-builder-blue200: #ceecff;\n  --exp-builder-blue300: #98cbff;\n  --exp-builder-blue400: #40a0ff;\n  --exp-builder-blue500: #036fe3;\n  --exp-builder-blue600: #0059c8;\n  --exp-builder-blue700: #0041ab;\n  --exp-builder-blue800: #003298;\n  --exp-builder-blue900: #002a8e;\n  --exp-builder-gray100: #f7f9fa;\n  --exp-builder-gray200: #e7ebee;\n  --exp-builder-gray300: #cfd9e0;\n  --exp-builder-gray400: #aec1cc;\n  --exp-builder-gray500: #67728a;\n  --exp-builder-gray600: #5a657c;\n  --exp-builder-gray700: #414d63;\n  --exp-builder-gray800: #1b273a;\n  --exp-builder-gray900: #111b2b;\n  --exp-builder-purple600: #6c3ecf;\n  --exp-builder-red200: #ffe0e0;\n  --exp-builder-red800: #7f0010;\n  --exp-builder-color-white: #ffffff;\n  --exp-builder-glow-primary: 0px 0px 0px 3px #e8f5ff;\n\n  /* RGB colors for applying opacity */\n  --exp-builder-blue100-rgb: 232, 245, 255;\n  --exp-builder-blue300-rgb: 152, 203, 255;\n\n  /* Spacing tokens from Forma 36: https://f36.contentful.com/tokens/spacing */\n  --exp-builder-spacing-s: 0.75rem;\n  --exp-builder-spacing-2xs: 0.25rem;\n\n  /* Typography tokens from Forma 36: https://f36.contentful.com/tokens/typography */\n  --exp-builder-font-size-l: 1rem;\n  --exp-builder-font-size-m: 0.875rem;\n  --exp-builder-font-stack-primary: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial,\n    sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol;\n  --exp-builder-line-height-condensed: 1.25;\n}\n";
+styleInject(css_248z$b);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -41408,7 +41408,9 @@ const INCOMING_EVENTS$1 = {
     /** @deprecated will be removed when dropping backward compatibility for old DND */
     HoverComponent: 'hoverComponent',
     UpdatedEntity: 'updatedEntity',
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
     AssembliesAdded: 'assembliesAdded',
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
     AssembliesRegistered: 'assembliesRegistered',
     /** @deprecated will be removed when dropping backward compatibility for old DND */
     MouseMove: 'mouseMove',
@@ -41471,6 +41473,7 @@ const CONTENTFUL_COMPONENTS$1 = {
         name: 'Carousel',
     },
 };
+const ASSEMBLY_DEFAULT_CATEGORY = 'Assemblies';
 const CF_STYLE_ATTRIBUTES = [
     'cfVisibility',
     'cfHorizontalAlignment',
@@ -43656,6 +43659,19 @@ function getTargetValueInPixels(targetWidthObject) {
             return targetWidthObject.value;
     }
 }
+/**
+ * Creates a component definition for an assembly. As all assemblies use the same definition in the SDK,
+ * all should be registered via this function.
+ */
+const createAssemblyDefinition = (definitionId) => {
+    return {
+        id: definitionId,
+        name: 'Component',
+        variables: {},
+        children: true,
+        category: ASSEMBLY_DEFAULT_CATEGORY,
+    };
+};
 
 class ParseError extends Error {
     constructor(message) {
@@ -47909,7 +47925,9 @@ const INCOMING_EVENTS = {
     /** @deprecated will be removed when dropping backward compatibility for old DND */
     HoverComponent: 'hoverComponent',
     UpdatedEntity: 'updatedEntity',
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
     AssembliesAdded: 'assembliesAdded',
+    /** @deprecated not needed after `patternResolution` was introduced. Will be removed in the next major version. */
     AssembliesRegistered: 'assembliesRegistered',
     /** @deprecated will be removed when dropping backward compatibility for old DND */
     MouseMove: 'mouseMove',
@@ -47935,7 +47953,6 @@ var StudioCanvasMode$2;
 })(StudioCanvasMode$2 || (StudioCanvasMode$2 = {}));
 const VISUAL_EDITOR_CONTAINER_ID = 'cf-visual-editor';
 const ASSEMBLY_NODE_TYPE = 'assembly';
-const ASSEMBLY_DEFAULT_CATEGORY = 'Assemblies';
 const ASSEMBLY_BLOCK_NODE_TYPE = 'assemblyBlock';
 const EMPTY_CONTAINER_SIZE = '80px';
 const HYPERLINK_DEFAULT_PATTERN = `/{locale}/{entry.fields.slug}/`;
@@ -48094,34 +48111,7 @@ const useBreakpoints = (breakpoints) => {
     return { resolveDesignValue };
 };
 
-// Note: During development, the hot reloading might empty this and it
-// stays empty leading to not rendering assemblies. Ideally, this is
-// integrated into the state machine to keep track of its state.
-const assembliesRegistry = new Map([]);
-const setAssemblies = (assemblies) => {
-    for (const assembly of assemblies) {
-        assembliesRegistry.set(assembly.sys.id, assembly);
-    }
-};
 const componentRegistry = new Map();
-const addComponentRegistration = (componentRegistration) => {
-    componentRegistry.set(componentRegistration.definition.id, componentRegistration);
-};
-const createAssemblyRegistration = ({ definitionId, definitionName, component, }) => {
-    const componentRegistration = componentRegistry.get(definitionId);
-    if (componentRegistration) {
-        return componentRegistration;
-    }
-    const definition = {
-        id: definitionId,
-        name: definitionName || 'Component',
-        variables: {},
-        children: true,
-        category: ASSEMBLY_DEFAULT_CATEGORY,
-    };
-    addComponentRegistration({ component, definition });
-    return componentRegistry.get(definitionId);
-};
 
 const useEditorStore = create((set, get) => ({
     dataSource: {},
@@ -48161,6 +48151,278 @@ const useEditorStore = create((set, get) => ({
     },
 }));
 
+function useEditorSubscriber(inMemoryEntitiesStore) {
+    const entityStore = inMemoryEntitiesStore((state) => state.entityStore);
+    const areEntitiesFetched = inMemoryEntitiesStore((state) => state.areEntitiesFetched);
+    const setEntitiesFetched = inMemoryEntitiesStore((state) => state.setEntitiesFetched);
+    const resetEntityStore = inMemoryEntitiesStore((state) => state.resetEntityStore);
+    const { updateTree, updateNodesByUpdatedEntity } = useTreeStore((state) => ({
+        updateTree: state.updateTree,
+        updateNodesByUpdatedEntity: state.updateNodesByUpdatedEntity,
+    }));
+    const unboundValues = useEditorStore((state) => state.unboundValues);
+    const dataSource = useEditorStore((state) => state.dataSource);
+    const setLocale = useEditorStore((state) => state.setLocale);
+    const setUnboundValues = useEditorStore((state) => state.setUnboundValues);
+    const setDataSource = useEditorStore((state) => state.setDataSource);
+    const reloadApp = () => {
+        sendMessage(OUTGOING_EVENTS.CanvasReload, undefined);
+        // Wait a moment to ensure that the message was sent
+        setTimeout(() => {
+            // Received a hot reload message from webpack dev server -> reload the canvas
+            window.location.reload();
+        }, 50);
+    };
+    reactExports.useEffect(() => {
+        sendMessage(OUTGOING_EVENTS.RequestComponentTreeUpdate, undefined);
+    }, []);
+    /**
+     * Fills up entityStore with entities from newDataSource and from the tree.
+     * Also manages "entity status" variables (areEntitiesFetched, isFetchingEntities)
+     */
+    const fetchMissingEntities = reactExports.useCallback(async (entityStore, newDataSource, tree) => {
+        // if we realize that there's nothing missing and nothing to fill-fetch before we do any async call,
+        // then we can simply return and not lock the EntityStore at all.
+        const startFetching = () => {
+            setEntitiesFetched(false);
+        };
+        const endFetching = () => {
+            setEntitiesFetched(true);
+        };
+        // Prepare L1 entities and deepReferences
+        const entityLinksL1 = Object.values(newDataSource);
+        /**
+         * Checks only for _missing_ L1 entities
+         * WARNING: Does NOT check for entity staleness/versions. If an entity is stale, it will NOT be considered missing.
+         *          If ExperienceBuilder wants to update stale entities, it should post  `▼UPDATED_ENTITY` message to SDK.
+         */
+        const isMissingL1Entities = (entityLinks) => {
+            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(entityLinks);
+            return Boolean(missingAssetIds.length) || Boolean(missingEntryIds.length);
+        };
+        /**
+         * PRECONDITION: all L1 entities are fetched
+         */
+        const isMissingL2Entities = (deepReferences) => {
+            const referentLinks = deepReferences
+                .map((deepReference) => deepReference.extractReferent(entityStore))
+                .filter(isLink$1);
+            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(referentLinks);
+            return Boolean(missingAssetIds.length) || Boolean(missingEntryIds.length);
+        };
+        /**
+         * POST_CONDITION: entityStore is has all L1 entities (aka headEntities)
+         */
+        const fillupL1 = async ({ entityLinksL1, }) => {
+            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(entityLinksL1);
+            await entityStore.fetchEntities({ missingAssetIds, missingEntryIds });
+        };
+        /**
+         * PRECONDITION: all L1 entites are fetched
+         */
+        const fillupL2 = async ({ deepReferences }) => {
+            const referentLinks = deepReferences
+                .map((deepReference) => deepReference.extractReferent(entityStore))
+                .filter(isLink$1);
+            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(referentLinks);
+            await entityStore.fetchEntities({ missingAssetIds, missingEntryIds });
+        };
+        try {
+            if (isMissingL1Entities(entityLinksL1)) {
+                startFetching();
+                await fillupL1({ entityLinksL1 });
+            }
+            const deepReferences = gatherDeepReferencesFromTree(tree.root, newDataSource, entityStore.getEntityFromLink.bind(entityStore));
+            if (isMissingL2Entities(deepReferences)) {
+                startFetching();
+                await fillupL2({ deepReferences });
+            }
+        }
+        catch (error) {
+            debug$1.error('[experiences-visual-editor-react::useEditorSubscriber] Failed fetching entities', { error });
+            throw error; // TODO: The original catch didn't let's rethrow; for the moment throw to see if we have any errors
+        }
+        finally {
+            endFetching();
+        }
+    }, [setEntitiesFetched]);
+    reactExports.useEffect(() => {
+        const onMessage = async (event) => {
+            let reason;
+            if ((reason = doesMismatchMessageSchema(event))) {
+                if (event.origin.startsWith('http://localhost') &&
+                    `${event.data}`.includes('webpackHotUpdate')) {
+                    reloadApp();
+                }
+                else {
+                    debug$1.warn(`[experiences-visual-editor-react::onMessage] Ignoring alien incoming message from origin [${event.origin}], due to: [${reason}]`, event);
+                }
+                return;
+            }
+            const eventData = tryParseMessage(event);
+            debug$1.debug(`[experiences-visual-editor-react::onMessage] Received message [${eventData.eventType}]`, eventData);
+            if (eventData.eventType === PostMessageMethods$2.REQUESTED_ENTITIES) {
+                // Expected message: This message is handled in the EntityStore to store fetched entities
+                return;
+            }
+            switch (eventData.eventType) {
+                case INCOMING_EVENTS.ExperienceUpdated: {
+                    const { tree, locale, changedNode, changedValueType } = eventData.payload;
+                    let newEntityStore = entityStore;
+                    if (entityStore.locale !== locale) {
+                        newEntityStore = new EditorModeEntityStore({ locale, entities: [] });
+                        setLocale(locale);
+                        resetEntityStore(newEntityStore);
+                    }
+                    // Below are mutually exclusive cases
+                    if (changedNode) {
+                        /**
+                         * On single node updates, we want to skip the process of getting the data (datasource and unbound values)
+                         * from tree. Since we know the updated node, we can skip that recursion everytime the tree updates and
+                         * just update the relevant data we need from the relevant node.
+                         *
+                         * We still update the tree here so we don't have a stale "tree"
+                         */
+                        if (changedValueType === 'BoundValue') {
+                            const newDataSource = { ...dataSource, ...changedNode.data.dataSource };
+                            setDataSource(newDataSource);
+                            await fetchMissingEntities(newEntityStore, newDataSource, tree);
+                        }
+                        else if (changedValueType === 'UnboundValue') {
+                            setUnboundValues({
+                                ...unboundValues,
+                                ...changedNode.data.unboundValues,
+                            });
+                        }
+                    }
+                    else {
+                        const { dataSource, unboundValues } = getDataFromTree(tree);
+                        setDataSource(dataSource);
+                        setUnboundValues(unboundValues);
+                        await fetchMissingEntities(newEntityStore, dataSource, tree);
+                    }
+                    // Update the tree when all necessary data is fetched and ready for rendering.
+                    updateTree(tree);
+                    break;
+                }
+                case INCOMING_EVENTS.AssembliesRegistered: {
+                    // Not necessary anymore since `patternResolution` which was introduced in 2024.
+                    break;
+                }
+                case INCOMING_EVENTS.AssembliesAdded: {
+                    // Not necessary anymore since `patternResolution` which was introduced in 2024.
+                    break;
+                }
+                case INCOMING_EVENTS.UpdatedEntity: {
+                    const { entity: updatedEntity, shouldRerender } = eventData.payload;
+                    if (updatedEntity) {
+                        const storedEntity = entityStore.entities.find((entity) => entity.sys.id === updatedEntity.sys.id);
+                        const didEntityChange = storedEntity?.sys.version !== updatedEntity.sys.version;
+                        entityStore.updateEntity(updatedEntity);
+                        // We traverse the whole tree, so this is a opt-in feature to only use it when required.
+                        if (shouldRerender && didEntityChange) {
+                            updateNodesByUpdatedEntity(updatedEntity.sys.id);
+                        }
+                    }
+                    break;
+                }
+                case INCOMING_EVENTS.RequestEditorMode: {
+                    break;
+                }
+                default: {
+                    const knownEvents = Object.values(INCOMING_EVENTS);
+                    const isDeprecatedMessage = knownEvents.includes(eventData.eventType);
+                    if (!isDeprecatedMessage) {
+                        debug$1.error(`[experiences-visual-editor-react::onMessage] Logic error, unsupported eventType: [${eventData.eventType}]`);
+                    }
+                }
+            }
+        };
+        window.addEventListener('message', onMessage);
+        return () => {
+            window.removeEventListener('message', onMessage);
+        };
+    }, [
+        entityStore,
+        setDataSource,
+        setLocale,
+        dataSource,
+        areEntitiesFetched,
+        fetchMissingEntities,
+        setUnboundValues,
+        unboundValues,
+        updateTree,
+        updateNodesByUpdatedEntity,
+        resetEntityStore,
+    ]);
+}
+
+const CircularDependencyErrorPlaceholder = ({ wrappingPatternIds, ...props }) => {
+    return (React$1.createElement("div", { ...props, "data-cf-node-error": "circular-pattern-dependency", style: {
+            border: '1px solid red',
+            background: 'rgba(255, 0, 0, 0.1)',
+            padding: '1rem 1rem 0 1rem',
+            width: '100%',
+            height: '100%',
+        } },
+        "Circular usage of patterns detected:",
+        React$1.createElement("ul", null, Array.from(wrappingPatternIds).map((patternId) => {
+            const entryLink = { sys: { type: 'Link', linkType: 'Entry', id: patternId } };
+            const entry = inMemoryEntities.maybeResolveLink(entryLink);
+            const entryTitle = entry?.fields?.title;
+            const text = entryTitle ? `${entryTitle} (${patternId})` : patternId;
+            return React$1.createElement("li", { key: patternId }, text);
+        }))));
+};
+
+class ImportedComponentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ImportedComponentError';
+    }
+}
+class ExperienceSDKError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ExperienceSDKError';
+    }
+}
+class ImportedComponentErrorBoundary extends React$1.Component {
+    componentDidCatch(error, _errorInfo) {
+        if (error.name === 'ImportedComponentError' || error.name === 'ExperienceSDKError') {
+            // This error was already handled by a nested error boundary and should be passed upwards
+            // We have to do this as we wrap every component on every layer with this error boundary and
+            // thus an error deep in the tree bubbles through many layers of error boundaries.
+            throw error;
+        }
+        // Differentiate between custom and SDK-provided components for error tracking
+        const ErrorClass = isContentfulComponent(this.props.componentId)
+            ? ExperienceSDKError
+            : ImportedComponentError;
+        const err = new ErrorClass(error.message);
+        err.stack = error.stack;
+        throw err;
+    }
+    render() {
+        return this.props.children;
+    }
+}
+
+const MissingComponentPlaceholder = ({ blockId }) => {
+    return (React$1.createElement("div", { style: {
+            border: '1px solid red',
+            width: '100%',
+            height: '100%',
+        } },
+        "Missing component '",
+        blockId,
+        "'"));
+};
+
+var css_248z$a = ".EditorBlock-module_emptySlot__za-Bi {\n  min-height: 80px;\n  min-width: 80px;\n}\n";
+var styles$1 = {"emptySlot":"EditorBlock-module_emptySlot__za-Bi"};
+styleInject(css_248z$a);
+
 var dist$1 = {};
 
 var isPlainObj = value => {
@@ -50594,8 +50856,8 @@ var VisualEditorMode;
     VisualEditorMode["InjectScript"] = "injectScript";
 })(VisualEditorMode || (VisualEditorMode = {}));
 
-var css_248z$2$1 = ".contentful-container{display:flex;pointer-events:all;position:relative}.contentful-container::-webkit-scrollbar{display:none}.cf-container-wrapper{position:relative;width:100%}.contentful-container:after{align-items:center;bottom:0;color:var(--exp-builder-gray400);content:\"\";display:block;display:flex;font-family:var(--exp-builder-font-stack-primary);font-size:12px;justify-content:center;left:0;overflow-x:clip;pointer-events:none;position:absolute;right:0;top:0;z-index:1}.contentful-section-label:after{content:\"Section\"}.contentful-container-label:after{content:\"Container\"}.contentful-container-link,.contentful-container-link:active,.contentful-container-link:focus-visible,.contentful-container-link:hover,.contentful-container-link:read-write,.contentful-container-link:visited{color:inherit;outline:unset;text-decoration:unset}";
-styleInject(css_248z$2$1);
+var css_248z$2 = ".contentful-container{display:flex;pointer-events:all;position:relative}.contentful-container::-webkit-scrollbar{display:none}.cf-container-wrapper{position:relative;width:100%}.contentful-container:after{align-items:center;bottom:0;color:var(--exp-builder-gray400);content:\"\";display:block;display:flex;font-family:var(--exp-builder-font-stack-primary);font-size:12px;justify-content:center;left:0;overflow-x:clip;pointer-events:none;position:absolute;right:0;top:0;z-index:1}.contentful-section-label:after{content:\"Section\"}.contentful-container-label:after{content:\"Container\"}.contentful-container-link,.contentful-container-link:active,.contentful-container-link:focus-visible,.contentful-container-link:hover,.contentful-container-link:read-write,.contentful-container-link:visited{color:inherit;outline:unset;text-decoration:unset}";
+styleInject(css_248z$2);
 
 const Flex = reactExports.forwardRef(({ id, children, onMouseEnter, onMouseUp, onMouseLeave, onMouseDown, onClick, flex, flexBasis, flexShrink, flexDirection, gap, justifyContent, justifyItems, justifySelf, alignItems, alignSelf, alignContent, order, flexWrap, flexGrow, className, cssStyles, ...props }, ref) => {
     return (React$1.createElement("div", { id: id, ref: ref, style: {
@@ -50632,315 +50894,16 @@ const Assembly = (props) => {
     return React$1.createElement("div", { "data-test-id": "assembly", ...props, style: assemblyStyle });
 };
 
-function useEditorSubscriber(inMemoryEntitiesStore) {
-    const entityStore = inMemoryEntitiesStore((state) => state.entityStore);
-    const areEntitiesFetched = inMemoryEntitiesStore((state) => state.areEntitiesFetched);
-    const setEntitiesFetched = inMemoryEntitiesStore((state) => state.setEntitiesFetched);
-    const resetEntityStore = inMemoryEntitiesStore((state) => state.resetEntityStore);
-    const { updateTree, updateNodesByUpdatedEntity } = useTreeStore((state) => ({
-        updateTree: state.updateTree,
-        updateNodesByUpdatedEntity: state.updateNodesByUpdatedEntity,
-    }));
-    const unboundValues = useEditorStore((state) => state.unboundValues);
-    const dataSource = useEditorStore((state) => state.dataSource);
-    const setLocale = useEditorStore((state) => state.setLocale);
-    const setUnboundValues = useEditorStore((state) => state.setUnboundValues);
-    const setDataSource = useEditorStore((state) => state.setDataSource);
-    const reloadApp = () => {
-        sendMessage(OUTGOING_EVENTS.CanvasReload, undefined);
-        // Wait a moment to ensure that the message was sent
-        setTimeout(() => {
-            // Received a hot reload message from webpack dev server -> reload the canvas
-            window.location.reload();
-        }, 50);
-    };
-    reactExports.useEffect(() => {
-        sendMessage(OUTGOING_EVENTS.RequestComponentTreeUpdate, undefined);
-    }, []);
-    /**
-     * Fills up entityStore with entities from newDataSource and from the tree.
-     * Also manages "entity status" variables (areEntitiesFetched, isFetchingEntities)
-     */
-    const fetchMissingEntities = reactExports.useCallback(async (entityStore, newDataSource, tree) => {
-        // if we realize that there's nothing missing and nothing to fill-fetch before we do any async call,
-        // then we can simply return and not lock the EntityStore at all.
-        const startFetching = () => {
-            setEntitiesFetched(false);
-        };
-        const endFetching = () => {
-            setEntitiesFetched(true);
-        };
-        // Prepare L1 entities and deepReferences
-        const entityLinksL1 = [
-            ...Object.values(newDataSource),
-            ...assembliesRegistry.values(), // we count assemblies here as "L1 entities", for convenience. Even though they're not headEntities.
-        ];
-        /**
-         * Checks only for _missing_ L1 entities
-         * WARNING: Does NOT check for entity staleness/versions. If an entity is stale, it will NOT be considered missing.
-         *          If ExperienceBuilder wants to update stale entities, it should post  `▼UPDATED_ENTITY` message to SDK.
-         */
-        const isMissingL1Entities = (entityLinks) => {
-            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(entityLinks);
-            return Boolean(missingAssetIds.length) || Boolean(missingEntryIds.length);
-        };
-        /**
-         * PRECONDITION: all L1 entities are fetched
-         */
-        const isMissingL2Entities = (deepReferences) => {
-            const referentLinks = deepReferences
-                .map((deepReference) => deepReference.extractReferent(entityStore))
-                .filter(isLink$1);
-            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(referentLinks);
-            return Boolean(missingAssetIds.length) || Boolean(missingEntryIds.length);
-        };
-        /**
-         * POST_CONDITION: entityStore is has all L1 entities (aka headEntities)
-         */
-        const fillupL1 = async ({ entityLinksL1, }) => {
-            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(entityLinksL1);
-            await entityStore.fetchEntities({ missingAssetIds, missingEntryIds });
-        };
-        /**
-         * PRECONDITION: all L1 entites are fetched
-         */
-        const fillupL2 = async ({ deepReferences }) => {
-            const referentLinks = deepReferences
-                .map((deepReference) => deepReference.extractReferent(entityStore))
-                .filter(isLink$1);
-            const { missingAssetIds, missingEntryIds } = entityStore.getMissingEntityIds(referentLinks);
-            await entityStore.fetchEntities({ missingAssetIds, missingEntryIds });
-        };
-        try {
-            if (isMissingL1Entities(entityLinksL1)) {
-                startFetching();
-                await fillupL1({ entityLinksL1 });
-            }
-            const deepReferences = gatherDeepReferencesFromTree(tree.root, newDataSource, entityStore.getEntityFromLink.bind(entityStore));
-            if (isMissingL2Entities(deepReferences)) {
-                startFetching();
-                await fillupL2({ deepReferences });
-            }
-        }
-        catch (error) {
-            debug$1.error('[experiences-visual-editor-react::useEditorSubscriber] Failed fetching entities', { error });
-            throw error; // TODO: The original catch didn't let's rethrow; for the moment throw to see if we have any errors
-        }
-        finally {
-            endFetching();
-        }
-    }, [setEntitiesFetched /* setFetchingEntities, assembliesRegistry */]);
-    reactExports.useEffect(() => {
-        const onMessage = async (event) => {
-            let reason;
-            if ((reason = doesMismatchMessageSchema(event))) {
-                if (event.origin.startsWith('http://localhost') &&
-                    `${event.data}`.includes('webpackHotUpdate')) {
-                    reloadApp();
-                }
-                else {
-                    debug$1.warn(`[experiences-visual-editor-react::onMessage] Ignoring alien incoming message from origin [${event.origin}], due to: [${reason}]`, event);
-                }
-                return;
-            }
-            const eventData = tryParseMessage(event);
-            debug$1.debug(`[experiences-visual-editor-react::onMessage] Received message [${eventData.eventType}]`, eventData);
-            if (eventData.eventType === PostMessageMethods$2.REQUESTED_ENTITIES) {
-                // Expected message: This message is handled in the EntityStore to store fetched entities
-                return;
-            }
-            switch (eventData.eventType) {
-                case INCOMING_EVENTS.ExperienceUpdated: {
-                    const { tree, locale, changedNode, changedValueType, assemblies } = eventData.payload;
-                    // Make sure to first store the assemblies before setting the tree and thus triggering a rerender
-                    if (assemblies) {
-                        setAssemblies(assemblies);
-                        // If the assemblyEntry is not yet fetched, this will be done below by
-                        // the imperative calls to fetchMissingEntities.
-                    }
-                    let newEntityStore = entityStore;
-                    if (entityStore.locale !== locale) {
-                        newEntityStore = new EditorModeEntityStore({ locale, entities: [] });
-                        setLocale(locale);
-                        resetEntityStore(newEntityStore);
-                    }
-                    // Below are mutually exclusive cases
-                    if (changedNode) {
-                        /**
-                         * On single node updates, we want to skip the process of getting the data (datasource and unbound values)
-                         * from tree. Since we know the updated node, we can skip that recursion everytime the tree updates and
-                         * just update the relevant data we need from the relevant node.
-                         *
-                         * We still update the tree here so we don't have a stale "tree"
-                         */
-                        if (changedValueType === 'BoundValue') {
-                            const newDataSource = { ...dataSource, ...changedNode.data.dataSource };
-                            setDataSource(newDataSource);
-                            await fetchMissingEntities(newEntityStore, newDataSource, tree);
-                        }
-                        else if (changedValueType === 'UnboundValue') {
-                            setUnboundValues({
-                                ...unboundValues,
-                                ...changedNode.data.unboundValues,
-                            });
-                        }
-                    }
-                    else {
-                        const { dataSource, unboundValues } = getDataFromTree(tree);
-                        setDataSource(dataSource);
-                        setUnboundValues(unboundValues);
-                        await fetchMissingEntities(newEntityStore, dataSource, tree);
-                    }
-                    // Update the tree when all necessary data is fetched and ready for rendering.
-                    updateTree(tree);
-                    break;
-                }
-                case INCOMING_EVENTS.AssembliesRegistered: {
-                    const { assemblies } = eventData.payload;
-                    assemblies.forEach((definition) => {
-                        addComponentRegistration({
-                            component: Assembly,
-                            definition,
-                        });
-                    });
-                    break;
-                }
-                case INCOMING_EVENTS.AssembliesAdded: {
-                    const { assembly, assemblyDefinition, } = eventData.payload;
-                    entityStore.updateEntity(assembly);
-                    // Using a Map here to avoid setting state and rerending all existing assemblies when a new assembly is added
-                    // TODO: Figure out if we can extend this love to data source and unbound values. Maybe that'll solve the blink
-                    // of all bound and unbound values when new values are added
-                    assembliesRegistry.set(assembly.sys.id, {
-                        sys: { id: assembly.sys.id, linkType: 'Entry', type: 'Link' },
-                    });
-                    if (assemblyDefinition) {
-                        addComponentRegistration({
-                            component: Assembly,
-                            definition: assemblyDefinition,
-                        });
-                    }
-                    break;
-                }
-                case INCOMING_EVENTS.UpdatedEntity: {
-                    const { entity: updatedEntity, shouldRerender } = eventData.payload;
-                    if (updatedEntity) {
-                        const storedEntity = entityStore.entities.find((entity) => entity.sys.id === updatedEntity.sys.id);
-                        const didEntityChange = storedEntity?.sys.version !== updatedEntity.sys.version;
-                        entityStore.updateEntity(updatedEntity);
-                        // We traverse the whole tree, so this is a opt-in feature to only use it when required.
-                        if (shouldRerender && didEntityChange) {
-                            updateNodesByUpdatedEntity(updatedEntity.sys.id);
-                        }
-                    }
-                    break;
-                }
-                case INCOMING_EVENTS.RequestEditorMode: {
-                    break;
-                }
-                default: {
-                    const knownEvents = Object.values(INCOMING_EVENTS);
-                    const isDeprecatedMessage = knownEvents.includes(eventData.eventType);
-                    if (!isDeprecatedMessage) {
-                        debug$1.error(`[experiences-visual-editor-react::onMessage] Logic error, unsupported eventType: [${eventData.eventType}]`);
-                    }
-                }
-            }
-        };
-        window.addEventListener('message', onMessage);
-        return () => {
-            window.removeEventListener('message', onMessage);
-        };
-    }, [
-        entityStore,
-        setDataSource,
-        setLocale,
-        dataSource,
-        areEntitiesFetched,
-        fetchMissingEntities,
-        setUnboundValues,
-        unboundValues,
-        updateTree,
-        updateNodesByUpdatedEntity,
-        resetEntityStore,
-    ]);
-}
-
-const CircularDependencyErrorPlaceholder = ({ wrappingPatternIds, ...props }) => {
-    return (React$1.createElement("div", { ...props, "data-cf-node-error": "circular-pattern-dependency", style: {
-            border: '1px solid red',
-            background: 'rgba(255, 0, 0, 0.1)',
-            padding: '1rem 1rem 0 1rem',
-            width: '100%',
-            height: '100%',
-        } },
-        "Circular usage of patterns detected:",
-        React$1.createElement("ul", null, Array.from(wrappingPatternIds).map((patternId) => {
-            const entryLink = { sys: { type: 'Link', linkType: 'Entry', id: patternId } };
-            const entry = inMemoryEntities.maybeResolveLink(entryLink);
-            const entryTitle = entry?.fields?.title;
-            const text = entryTitle ? `${entryTitle} (${patternId})` : patternId;
-            return React$1.createElement("li", { key: patternId }, text);
-        }))));
-};
-
-class ImportedComponentError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ImportedComponentError';
-    }
-}
-class ExperienceSDKError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ExperienceSDKError';
-    }
-}
-class ImportedComponentErrorBoundary extends React$1.Component {
-    componentDidCatch(error, _errorInfo) {
-        if (error.name === 'ImportedComponentError' || error.name === 'ExperienceSDKError') {
-            // This error was already handled by a nested error boundary and should be passed upwards
-            // We have to do this as we wrap every component on every layer with this error boundary and
-            // thus an error deep in the tree bubbles through many layers of error boundaries.
-            throw error;
-        }
-        // Differentiate between custom and SDK-provided components for error tracking
-        const ErrorClass = isContentfulComponent(this.props.componentId)
-            ? ExperienceSDKError
-            : ImportedComponentError;
-        const err = new ErrorClass(error.message);
-        err.stack = error.stack;
-        throw err;
-    }
-    render() {
-        return this.props.children;
-    }
-}
-
-const MissingComponentPlaceholder = ({ blockId }) => {
-    return (React$1.createElement("div", { style: {
-            border: '1px solid red',
-            width: '100%',
-            height: '100%',
-        } },
-        "Missing component '",
-        blockId,
-        "'"));
-};
-
-var css_248z$2 = ".EditorBlock-module_emptySlot__za-Bi {\n  min-height: 80px;\n  min-width: 80px;\n}\n";
-var styles$1 = {"emptySlot":"EditorBlock-module_emptySlot__za-Bi"};
-styleInject(css_248z$2);
-
 const useComponentRegistration = (node) => {
     return reactExports.useMemo(() => {
-        let registration = componentRegistry.get(node.data.blockId);
-        if (node.type === ASSEMBLY_NODE_TYPE && !registration) {
-            registration = createAssemblyRegistration({
-                definitionId: node.data.blockId,
+        if (node.type === ASSEMBLY_NODE_TYPE) {
+            // The definition and component are the same for all assemblies
+            return {
                 component: Assembly,
-            });
+                definition: createAssemblyDefinition(node.data.blockId),
+            };
         }
+        const registration = componentRegistry.get(node.data.blockId);
         if (!registration) {
             debug$1.warn(`[experiences-visual-editor-react::useComponentRegistration] Component registration not found for component with id: "${node.data.blockId}". The registered component might have been removed from the code. To proceed, remove the component manually from the layers tab.`);
             return undefined;