@contentful/experiences-visual-editor-react 3.3.0-dev-20250820T0950-c569ea0.0 → 3.3.0-dev-20250820T1056-fd92026.0

package/dist/renderApp.js

@@ -44736,6 +44736,11 @@ const isLink$1 = (maybeLink) => {
 /**
  * This module encapsulates format of the path to a deep reference.
  */
+const isPreboundProp = (variable) => {
+    return (variable.type === 'BoundValue' &&
+        typeof variable.isPrebound === 'boolean' &&
+        !!variable.pathsByContentType);
+};
 const parseDataSourcePathIntoFieldset$1 = (path) => {
     const parsedPath = parseDeepPath$1(path);
     if (null === parsedPath) {
@@ -44774,6 +44779,35 @@ const isDeepPath$1 = (deepPathCandidate) => {
     }
     return deepPathParsed.fields.length > 1;
 };
+const isDeepPrebinding = (boundValueProperty) => {
+    if (!boundValueProperty?.path || boundValueProperty.type !== 'BoundValue') {
+        return false;
+    }
+    if (!isPreboundProp(boundValueProperty)) {
+        return false;
+    }
+    if (isDeepPath$1(boundValueProperty.path)) {
+        return true;
+    }
+    const hasDeepPathByContentType = Object.values(boundValueProperty.pathsByContentType || {}).some((val) => isDeepPath$1(val.path));
+    return hasDeepPathByContentType;
+};
+const getPrebindingPathBySourceEntry = (preboundValueProperty, getHeadEntityByDataSourceKey) => {
+    if (!isPreboundProp(preboundValueProperty)) {
+        return undefined;
+    }
+    // incomplete path due to several content types and not known default source
+    const [, dataSourceKey] = preboundValueProperty.path.split('/');
+    if (!dataSourceKey) {
+        return undefined;
+    }
+    const headEntity = getHeadEntityByDataSourceKey(dataSourceKey);
+    if (headEntity?.sys.type !== 'Entry') {
+        return undefined;
+    }
+    const contentTypeId = headEntity.sys.contentType.sys.id;
+    return preboundValueProperty.pathsByContentType?.[contentTypeId]?.path;
+};
 const parseDeepPath$1 = (deepPathCandidate) => {
     // ALGORITHM:
     // We start with deep path in form:
@@ -46110,7 +46144,7 @@ class DeepReference {
         return new DeepReference(opt);
     }
 }
-function gatherDeepReferencesFromTree(startingNode, dataSource) {
+function gatherDeepReferencesFromTree(startingNode, dataSource, getEntityFromLink) {
     const deepReferences = [];
     treeVisit(startingNode, (node) => {
         if (!node.data.props)
@@ -46118,12 +46152,27 @@ function gatherDeepReferencesFromTree(startingNode, dataSource) {
         for (const [, variableMapping] of Object.entries(node.data.props)) {
             if (variableMapping.type !== 'BoundValue')
                 continue;
-            if (!isDeepPath$1(variableMapping.path))
-                continue;
-            deepReferences.push(DeepReference.from({
-                path: variableMapping.path,
-                dataSource,
-            }));
+            if (isDeepPath$1(variableMapping.path)) {
+                deepReferences.push(DeepReference.from({
+                    path: variableMapping.path,
+                    dataSource,
+                }));
+            }
+            else if (isPreboundProp(variableMapping) && isDeepPrebinding(variableMapping)) {
+                const getEntityByDataSourceKey = (dataSourceKey) => {
+                    const entityLink = dataSource[dataSourceKey];
+                    if (!entityLink)
+                        return undefined;
+                    return getEntityFromLink(entityLink);
+                };
+                const deepPrebindingPath = getPrebindingPathBySourceEntry(variableMapping, getEntityByDataSourceKey);
+                if (!deepPrebindingPath)
+                    continue;
+                deepReferences.push(DeepReference.from({
+                    path: deepPrebindingPath,
+                    dataSource,
+                }));
+            }
         }
     });
     return deepReferences;
@@ -49183,10 +49232,6 @@ const isLink = (maybeLink) => {
     const link = maybeLink;
     return Boolean(link.sys?.id) && link.sys?.type === 'Link' && Boolean(link.sys?.linkType);
 };
-
-/**
- * This module encapsulates format of the path to a deep reference.
- */
 const parseDataSourcePathIntoFieldset = (path) => {
     const parsedPath = parseDeepPath(path);
     if (null === parsedPath) {
@@ -49675,7 +49720,6 @@ function useEditorSubscriber(inMemoryEntitiesStore) {
             ...Object.values(newDataSource),
             ...assembliesRegistry.values(), // we count assemblies here as "L1 entities", for convenience. Even though they're not headEntities.
         ];
-        const deepReferences = gatherDeepReferencesFromTree(tree.root, 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.
@@ -49717,6 +49761,7 @@ function useEditorSubscriber(inMemoryEntitiesStore) {
                 startFetching();
                 await fillupL1({ entityLinksL1 });
             }
+            const deepReferences = gatherDeepReferencesFromTree(tree.root, newDataSource, entityStore.getEntityFromLink.bind(entityStore));
             if (isMissingL2Entities(deepReferences)) {
                 startFetching();
                 await fillupL2({ deepReferences });
@@ -50083,16 +50128,32 @@ const useComponentProps = ({ node, entityStore, areEntitiesFetched, resolveDesig
                 };
             }
             else if (variableMapping.type === 'BoundValue') {
-                const [, uuid, path] = variableMapping.path.split('/');
-                const binding = dataSource[uuid];
-                const variableDefinition = definition.variables[variableName];
-                let boundValue = transformBoundContentValue(node.data.props, entityStore, binding, resolveDesignValue, variableName, variableDefinition.type, variableMapping.path);
+                // maybePath, because prebound props would have the type 'BoundValue' but the path would be incomplete
+                // eg: "/uuid" vs "/uuid/fields/[fileName]/~locale" as the regular BoundValue would have
+                const [, uuid, maybePath] = variableMapping.path.split('/');
+                const link = dataSource[uuid];
+                let boundValue;
+                // starting from here, if the prop is of type 'BoundValue', and has prebinding
+                // we are going to resolve the incomplete path
+                if (link && isPreboundProp(variableMapping) && variableMapping.isPrebound) {
+                    const prebindingPath = getPrebindingPathBySourceEntry(variableMapping, (dataSourceKey) => {
+                        const link = dataSource[dataSourceKey];
+                        return entityStore.getEntityFromLink(link);
+                    }) ?? variableMapping.path;
+                    // this allows us to resolve it regularly
+                    boundValue = transformBoundContentValue(node.data.props, entityStore, link, resolveDesignValue, variableName, variableDefinition.type, prebindingPath);
+                }
+                else {
+                    // here we resolve the regular bound value
+                    const variableDefinition = definition.variables[variableName];
+                    boundValue = transformBoundContentValue(node.data.props, entityStore, link, resolveDesignValue, variableName, variableDefinition.type, variableMapping.path);
+                }
                 // In some cases, there may be an asset linked in the path, so we need to consider this scenario:
                 // If no 'boundValue' is found, we also attempt to extract the value associated with the second-to-last item in the path.
                 // If successful, it means we have identified the linked asset.
-                if (!boundValue) {
+                if (!boundValue && maybePath) {
                     const maybeBoundAsset = areEntitiesFetched
-                        ? entityStore.getValue(binding, path.split('/').slice(0, -2))
+                        ? entityStore.getValue(link, maybePath.split('/').slice(0, -2))
                         : undefined;
                     if (isLinkToAsset(maybeBoundAsset)) {
                         boundValue = maybeBoundAsset;