@contentful/experiences-core 3.6.3-dev-20250916T1219-c183de1.0 → 3.7.0-dev-20250917T1203-0e23897.0

package/dist/deep-binding/DeepReference.d.ts

@@ -1,6 +1,8 @@
 import { DataSourceEntryValueType, Link, ExperienceEntry, ExperienceTreeNode } from '../types.js';
+import { Entry } from 'contentful';
 import { EntityFromLink, EntityStoreBase } from '../entity/EntityStoreBase.js';
 import { ExperienceDataSource } from '@contentful/experiences-validators';
+import { PrebindingData } from '../utils/extractPrebindingData.js';
 
 type DeepReferenceOpts = {
     path: string;
@@ -22,6 +24,21 @@ declare class DeepReference {
     static from(opt: DeepReferenceOpts): DeepReference;
 }
 declare function gatherDeepReferencesFromExperienceEntry(experienceEntry: ExperienceEntry): DeepReference[];
+declare function gatherDeepPrebindingReferencesFromExperienceEntry({ experienceEntry, fetchedPatterns, prebindingDataByPatternId, fetchedLevel1Entries, }: {
+    experienceEntry: ExperienceEntry;
+    fetchedPatterns: Array<ExperienceEntry>;
+    prebindingDataByPatternId: Record<string, PrebindingData>;
+    fetchedLevel1Entries: Array<Entry>;
+}): DeepReference[];
+declare function gatherDeepPrebindingReferencesFromPatternEntry({ patternEntry, fetchedPatterns, prebindingDataByPatternId, fetchedLevel1Entries, }: {
+    patternEntry: ExperienceEntry;
+    fetchedPatterns: Array<ExperienceEntry>;
+    prebindingDataByPatternId: Record<string, PrebindingData>;
+    fetchedLevel1Entries: Array<Entry>;
+}): DeepReference[];
+/**
+ * used in editor mode. for delivery mode see `gatherDeepReferencesFromExperienceEntry`
+ */
 declare function gatherDeepReferencesFromTree(startingNode: ExperienceTreeNode, dataSource: ExperienceDataSource, getEntityFromLink: EntityStoreBase['getEntityFromLink']): DeepReference[];
 
-export { DeepReference, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree };
+export { DeepReference, gatherDeepPrebindingReferencesFromExperienceEntry, gatherDeepPrebindingReferencesFromPatternEntry, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree };

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export { doesMismatchMessageSchema, tryParseMessage, validateExperienceBuilderCo
 export { extractLeafLinksReferencedFromExperience } from './utils/schema/experienceSchema.js';
 export { FnShouldFollowReferencesOfEntryField, extractReferencesFromEntries, extractReferencesFromEntriesAsIds, referencesOf, uniqueById } from './utils/schema/references.js';
 export { splitDirectAndSlotChildren } from './utils/splitDirectAndSlotChildren.js';
+export { PrebindingData, extractPrebindingDataByPatternId, flattenNestedPatterns, generateDefaultDataSourceForPrebindingDefinition, getTargetPatternMappingsForParameter } from './utils/extractPrebindingData.js';
 export { builtInStyles, columnsBuiltInStyles, containerBuiltInStyles, dividerBuiltInStyles, optionalBuiltInStyles, sectionBuiltInStyles, singleColumnBuiltInStyles } from './definitions/styles.js';
 export { EditorModeEntityStore } from './entity/EditorModeEntityStore.js';
 export { EntityStore } from './entity/EntityStore.js';
@@ -38,4 +39,4 @@ export { fetchExperienceEntry } from './fetchers/fetchExperienceEntry.js';
 export { defineDesignTokens, designTokensRegistry, getDesignTokenRegistration, resetDesignTokenRegistry } from './registries/designTokenRegistry.js';
 export { breakpointsRegistry, defineBreakpoints, getBreakpointRegistration, resetBreakpointsRegistry, runBreakpointsValidation } from './registries/breakpointsRegistry.js';
 export { defineSdkOptions, getSdkOptions, sdkOptionsRegistry } from './registries/sdkOptionsRegistry.js';
-export { DeepReference, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree } from './deep-binding/DeepReference.js';
+export { DeepReference, gatherDeepPrebindingReferencesFromExperienceEntry, gatherDeepPrebindingReferencesFromPatternEntry, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree } from './deep-binding/DeepReference.js';

package/dist/index.js

@@ -3515,6 +3515,118 @@ const splitDirectAndSlotChildren = (allChildNodes, componentDefinition) => {
     return { slotNodesMap, directChildNodes };
 };
 
+const flattenNestedPatterns = (fetchedPatterns) => {
+    const patternsById = {};
+    const queue = [...fetchedPatterns];
+    while (queue.length) {
+        const pattern = queue.shift();
+        if (!pattern) {
+            continue;
+        }
+        if (patternsById[pattern.sys.id]) {
+            continue;
+        }
+        patternsById[pattern.sys.id] = pattern;
+        if (!Array.isArray(pattern.fields.usedComponents) || !pattern.fields.usedComponents.length) {
+            continue;
+        }
+        for (const nestedPattern of pattern.fields.usedComponents) {
+            if (!isLink(nestedPattern)) {
+                queue.push(nestedPattern);
+            }
+        }
+    }
+    return Object.values(patternsById);
+};
+/**
+ * Given a list of patterns, extract the prebinding data into a more digestable format indexed by the pattern entry id
+ * @param patterns a list of pattern entries
+ * @returns a map of pattern entry ids to their prebinding data
+ */
+const extractPrebindingDataByPatternId = (patterns) => {
+    const prebindingDataByPatternId = {};
+    for (const pattern of patterns) {
+        const patternId = pattern.sys.id;
+        const [prebindingDefinition] = pattern.fields.componentSettings?.prebindingDefinitions ?? [];
+        if (!prebindingDefinition)
+            continue;
+        const [nativeParameterId] = Object.entries(prebindingDefinition.parameterDefinitions ?? {}).find(([, value]) => value.passToNodes === undefined) ?? [];
+        const prebindingData = {
+            prebindingDefinitionId: prebindingDefinition.id,
+            parameterIds: Object.keys(prebindingDefinition.parameterDefinitions),
+            nativeParameterId,
+            parameterDefinitions: prebindingDefinition.parameterDefinitions,
+            variableMappings: prebindingDefinition.variableMappings,
+        };
+        prebindingDataByPatternId[patternId] = prebindingData;
+    }
+    return prebindingDataByPatternId;
+};
+const generateDefaultDataSourceForPrebindingDefinition = (prebindingDefinitions = []) => {
+    if (!prebindingDefinitions ||
+        !Array.isArray(prebindingDefinitions) ||
+        !prebindingDefinitions.length) {
+        return { dataSource: {}, parameters: {} };
+    }
+    const prebindingDefinition = prebindingDefinitions[0];
+    const dataSource = {};
+    const parameters = {};
+    for (const [parameterId, parameterDefinition] of Object.entries(prebindingDefinition.parameterDefinitions ?? {})) {
+        if (parameterDefinition.defaultSource && isLink(parameterDefinition.defaultSource.link)) {
+            const dataSourceKey = generateRandomId(7);
+            dataSource[dataSourceKey] = parameterDefinition.defaultSource.link;
+            parameters[parameterId] = {
+                type: 'BoundValue',
+                path: `/${dataSourceKey}`,
+            };
+        }
+    }
+    return {
+        dataSource,
+        parameters,
+    };
+};
+function getTargetPatternMappingsForParameter({ fetchedPatterns, prebindingDataByPatternId, patternNodeDefinitionId, parameterId, }) {
+    const patternPrebindingData = prebindingDataByPatternId[patternNodeDefinitionId];
+    if (!patternPrebindingData)
+        return undefined;
+    if (patternPrebindingData.parameterIds.includes(parameterId)) {
+        if (patternPrebindingData.nativeParameterId === parameterId) {
+            if (!patternPrebindingData.variableMappings)
+                return undefined;
+            return Object.fromEntries(Object.entries(patternPrebindingData.variableMappings).filter(([, mapping]) => mapping.parameterId === parameterId));
+        }
+        else {
+            const parameterDefinition = patternPrebindingData.parameterDefinitions[parameterId];
+            if (!parameterDefinition || !parameterDefinition.passToNodes)
+                return undefined;
+            const patternEntry = fetchedPatterns.find((entry) => entry.sys.id === patternNodeDefinitionId);
+            if (!patternEntry)
+                return undefined;
+            let nestedPatternNode;
+            treeVisit({
+                definitionId: 'root',
+                parameters: {},
+                children: patternEntry.fields.componentTree.children,
+            }, (node) => {
+                if (node.id === parameterDefinition.passToNodes?.[0].nodeId) {
+                    nestedPatternNode = node;
+                }
+                return undefined;
+            });
+            if (!nestedPatternNode) {
+                return undefined;
+            }
+            return getTargetPatternMappingsForParameter({
+                fetchedPatterns,
+                prebindingDataByPatternId,
+                patternNodeDefinitionId: nestedPatternNode.definitionId,
+                parameterId: parameterDefinition.passToNodes?.[0].parameterId,
+            });
+        }
+    }
+}
+
 const sendMessage = (eventType, data) => {
     if (typeof window === 'undefined') {
         return;
@@ -4341,7 +4453,7 @@ function gatherDeepReferencesFromExperienceEntry(experienceEntry) {
     }, (node) => {
         if (!node.variables)
             return;
-        for (const [, variableMapping] of Object.entries(node.variables)) {
+        for (const variableMapping of Object.values(node.variables)) {
             if (variableMapping.type !== 'BoundValue')
                 continue;
             if (!isDeepPath(variableMapping.path))
@@ -4354,6 +4466,99 @@ function gatherDeepReferencesFromExperienceEntry(experienceEntry) {
     });
     return deepReferences;
 }
+function gatherDeepPrebindingReferencesFromExperienceEntry({ experienceEntry, fetchedPatterns, prebindingDataByPatternId, fetchedLevel1Entries, }) {
+    const deepPrebindingReferences = [];
+    const dataSource = experienceEntry.fields.dataSource;
+    const { children } = experienceEntry.fields.componentTree;
+    treeVisit({
+        definitionId: 'root',
+        parameters: {},
+        children,
+    }, (node) => {
+        if (!node.parameters)
+            return;
+        for (const [parameterId, parameterValue] of Object.entries(node.parameters)) {
+            const dataSourceKey = parameterValue.path.split('/')[1];
+            const headEntryLink = dataSource[dataSourceKey];
+            if (!headEntryLink)
+                continue;
+            if (headEntryLink.sys.linkType !== 'Entry')
+                continue;
+            const headEntry = fetchedLevel1Entries.find((entry) => entry.sys.id === headEntryLink.sys.id);
+            if (!headEntry)
+                continue;
+            const headEntryContentTypeId = headEntry.sys.contentType.sys.id;
+            // if experience, we don't have any hoisted data on the given experienceEntry
+            // and we have to lookup the pattern instead
+            const variableMappings = getTargetPatternMappingsForParameter({
+                fetchedPatterns,
+                prebindingDataByPatternId,
+                patternNodeDefinitionId: node.definitionId,
+                parameterId,
+            });
+            if (!variableMappings)
+                continue;
+            for (const mappingData of Object.values(variableMappings)) {
+                const targetMapping = mappingData.pathsByContentType[headEntryContentTypeId];
+                if (!targetMapping)
+                    continue;
+                // mapping doesn't start with /uuid, but instead starts with /fields
+                // so we add /uuid to make it match the binding path format
+                const path = `/${dataSourceKey}${targetMapping.path}`;
+                if (!isDeepPath(path))
+                    continue;
+                deepPrebindingReferences.push(DeepReference.from({
+                    path,
+                    dataSource,
+                }));
+            }
+        }
+    });
+    return deepPrebindingReferences;
+}
+function gatherDeepPrebindingReferencesFromPatternEntry({ patternEntry, fetchedPatterns, prebindingDataByPatternId, fetchedLevel1Entries, }) {
+    const deepPrebindingReferences = [];
+    // patterns can't have parameters in their CDA/CMA JSON, so we can generate random ids here
+    const { dataSource, parameters } = generateDefaultDataSourceForPrebindingDefinition(patternEntry.fields.componentSettings?.prebindingDefinitions);
+    for (const [parameterId, parameterValue] of Object.entries(parameters)) {
+        const dataSourceKey = parameterValue.path.split('/')[1];
+        const headEntryLink = dataSource[dataSourceKey];
+        if (!headEntryLink)
+            continue;
+        if (headEntryLink.sys.linkType !== 'Entry')
+            continue;
+        const headEntry = fetchedLevel1Entries.find((entry) => entry.sys.id === headEntryLink.sys.id);
+        if (!headEntry)
+            continue;
+        const headEntryContentTypeId = headEntry.sys.contentType.sys.id;
+        const variableMappings = getTargetPatternMappingsForParameter({
+            fetchedPatterns,
+            prebindingDataByPatternId,
+            patternNodeDefinitionId: patternEntry.sys.id,
+            parameterId,
+        });
+        if (!variableMappings)
+            continue;
+        for (const mappingData of Object.values(variableMappings)) {
+            const targetMapping = mappingData.pathsByContentType[headEntryContentTypeId];
+            if (!targetMapping)
+                continue;
+            // mapping doesn't start with /uuid, but instead starts with /fields
+            // so we add /uuid to make it match the binding path format
+            const path = `/${dataSourceKey}${targetMapping.path}`;
+            if (!isDeepPath(path))
+                continue;
+            deepPrebindingReferences.push(DeepReference.from({
+                path,
+                dataSource,
+            }));
+        }
+    }
+    return deepPrebindingReferences;
+}
+/**
+ * used in editor mode. for delivery mode see `gatherDeepReferencesFromExperienceEntry`
+ */
 function gatherDeepReferencesFromTree(startingNode, dataSource, getEntityFromLink) {
     const deepReferences = [];
     treeVisit(startingNode, (node) => {
@@ -4560,7 +4765,6 @@ const fetchReferencedEntities = async ({ client, experienceEntry, locale, }) =>
     if (!isExperienceEntry(experienceEntry)) {
         throw new Error('Failed to fetch experience entities. Provided "experienceEntry" does not match experience entry schema');
     }
-    const deepReferences = gatherDeepReferencesFromExperienceEntry(experienceEntry);
     const entryIds = new Set();
     const assetIds = new Set();
     for (const dataBinding of Object.values(experienceEntry.fields.dataSource)) {
@@ -4578,12 +4782,52 @@ const fetchReferencedEntities = async ({ client, experienceEntry, locale, }) =>
         fetchAllEntries({ client, ids: [...entryIds], locale }),
         fetchAllAssets({ client, ids: [...assetIds], locale }),
     ]);
-    const { autoFetchedReferentAssets, autoFetchedReferentEntries } = gatherAutoFetchedReferentsFromIncludes(deepReferences, entriesResponse);
+    const usedPatterns = experienceEntry.fields.usedComponents ?? [];
+    const isRenderingExperience = Boolean(!experienceEntry.fields.componentSettings);
+    const deepReferences = gatherDeepReferencesFromExperienceEntry(experienceEntry);
+    // If we are previewing a pattern, we want to include the entry itself as well
+    const fetchedPatterns = (isRenderingExperience ? usedPatterns : [...usedPatterns, experienceEntry]);
+    const allFetchedPatterns = flattenNestedPatterns(fetchedPatterns);
+    const prebindingDataByPatternId = extractPrebindingDataByPatternId(allFetchedPatterns);
+    // Patterns do not have dataSource stored in their dataSource field, so head entities won't be there and we need to fetch them
+    if (!isRenderingExperience) {
+        const { dataSource } = generateDefaultDataSourceForPrebindingDefinition(experienceEntry.fields.componentSettings?.prebindingDefinitions);
+        if (Object.keys(dataSource).length) {
+            const prebindingEntriesResponse = await fetchAllEntries({
+                client,
+                ids: Object.values(dataSource).map((link) => link.sys.id),
+                locale,
+            });
+            entriesResponse.items.push(...prebindingEntriesResponse.items);
+            entriesResponse.includes.Asset.push(...(prebindingEntriesResponse.includes?.Asset ?? []));
+            entriesResponse.includes.Entry.push(...(prebindingEntriesResponse.includes?.Entry ?? []));
+        }
+    }
+    // normally, for experience entry, there should be no need to call this method, as `includes=2` will have them resolved
+    // because the entries used for pre-binding are stored in both - the layout of the experience, as well as the dataSource field
+    const deepPrebindingReferences = isRenderingExperience
+        ? gatherDeepPrebindingReferencesFromExperienceEntry({
+            experienceEntry: experienceEntry,
+            fetchedPatterns: allFetchedPatterns,
+            prebindingDataByPatternId,
+            fetchedLevel1Entries: entriesResponse.items,
+        })
+        : // however, for patterns, we have to do it by hand, because a pattern entry doesn't save the pre-binding data neither in the
+            // layout nor in the dataSource field.
+            // for consistency, as well as to be future safe from the change to "includes=2", I added methods for both
+            gatherDeepPrebindingReferencesFromPatternEntry({
+                patternEntry: experienceEntry,
+                fetchedPatterns: allFetchedPatterns,
+                prebindingDataByPatternId,
+                fetchedLevel1Entries: entriesResponse.items,
+            });
+    const allDeepReferences = [...deepReferences, ...deepPrebindingReferences];
+    const { autoFetchedReferentAssets, autoFetchedReferentEntries } = gatherAutoFetchedReferentsFromIncludes(allDeepReferences, entriesResponse);
     // Using client getEntries resolves all linked entry references, so we do not need to resolve entries in usedComponents
     const allResolvedEntries = [
         ...(entriesResponse?.items ?? []),
         ...(entriesResponse.includes?.Entry ?? []),
-        ...(experienceEntry.fields.usedComponents || []),
+        ...(usedPatterns || []),
         ...autoFetchedReferentEntries,
     ];
     const allResolvedAssets = [
@@ -4592,8 +4836,14 @@ const fetchReferencedEntities = async ({ client, experienceEntry, locale, }) =>
         ...autoFetchedReferentAssets,
     ];
     return {
-        entries: allResolvedEntries,
-        assets: allResolvedAssets,
+        // we have to drop duplicates, becasue of the merge of deepReferences and deepPrebindingReferences above
+        // If not, the same entity might appear in this array more than once
+        entries: [
+            ...new Map(allResolvedEntries.map((entry) => [entry.sys.id, entry])).values(),
+        ],
+        assets: [
+            ...new Map(allResolvedAssets.map((asset) => [asset.sys.id, asset])).values(),
+        ],
     };
 };
 
@@ -4872,5 +5122,5 @@ async function fetchById({ client, experienceTypeId, id, localeCode, isEditorMod
     }
 }
 
-export { BREAKPOINTS_STRATEGY_DESKTOP_FIRST, BREAKPOINTS_STRATEGY_MOBILE_FIRST, DebugLogger, DeepReference, EditorModeEntityStore, EntityStore, EntityStoreBase, MEDIA_QUERY_REGEXP, VisualEditorMode, addLocale, addMinHeightForEmptyStructures, breakpointsRegistry, buildCfStyles, buildStyleTag, buildTemplate, builtInStyles, calculateNodeDefaultHeight, checkIsAssemblyDefinition, checkIsAssemblyEntry, checkIsAssemblyNode, columnsBuiltInStyles, containerBuiltInStyles, createExperience, debug, defineBreakpoints, defineDesignTokens, defineSdkOptions, designTokensRegistry, detachExperienceStyles, detectBreakpointsStrategy, disableDebug, dividerBuiltInStyles, doesMismatchMessageSchema, enableDebug, extractLeafLinksReferencedFromExperience, extractReferencesFromEntries, extractReferencesFromEntriesAsIds, fetchAllAssets, fetchAllEntries, fetchById, fetchBySlug, fetchExperienceEntry, fetchReferencedEntities, findOutermostCoordinates, flattenDesignTokenRegistry, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree, generateRandomId, getActiveBreakpointIndex, getBreakpointRegistration, getDataFromTree, getDesignTokenRegistration, getElementCoordinates, getFallbackBreakpointIndex, getPrebindingPathBySourceEntry, getSdkOptions, getTargetValueInPixels, getTemplateValue, getValueForBreakpoint, inMemoryEntities, inMemoryEntitiesStore, indexByBreakpoint, isArrayOfLinks, isAsset, isCfStyleAttribute, isComponentAllowedOnRoot, isContentfulComponent, isContentfulStructureComponent, isDeepPath, isDeepPrebinding, isElementHidden, isEntry, isExperienceEntry, isLink, isLinkToAsset, isLinkToEntry, isPatternComponent, isPatternEntry, isPreboundProp, isStructureWithRelativeHeight, isValidBreakpointValue, lastPathNamedSegmentEq, localizeEntity, maybePopulateDesignTokenValue, mediaQueryMatcher, mergeDesignValuesByBreakpoint, optionalBuiltInStyles, parseCSSValue, parseDataSourcePathIntoFieldset, parseDataSourcePathWithL1DeepBindings, referencesOf, resetBreakpointsRegistry, resetDesignTokenRegistry, resolveBackgroundImageBinding, resolveHyperlinkPattern, runBreakpointsValidation, sanitizeNodeProps, sdkOptionsRegistry, sectionBuiltInStyles, sendMessage, setDebugLevel, singleColumnBuiltInStyles, splitDirectAndSlotChildren, stringifyCssProperties, toCSSAttribute, toMediaQuery, transformBoundContentValue, transformVisibility, treeMap, treeVisit, tryParseMessage, uniqueById, useInMemoryEntities, validateExperienceBuilderConfig };
+export { BREAKPOINTS_STRATEGY_DESKTOP_FIRST, BREAKPOINTS_STRATEGY_MOBILE_FIRST, DebugLogger, DeepReference, EditorModeEntityStore, EntityStore, EntityStoreBase, MEDIA_QUERY_REGEXP, VisualEditorMode, addLocale, addMinHeightForEmptyStructures, breakpointsRegistry, buildCfStyles, buildStyleTag, buildTemplate, builtInStyles, calculateNodeDefaultHeight, checkIsAssemblyDefinition, checkIsAssemblyEntry, checkIsAssemblyNode, columnsBuiltInStyles, containerBuiltInStyles, createExperience, debug, defineBreakpoints, defineDesignTokens, defineSdkOptions, designTokensRegistry, detachExperienceStyles, detectBreakpointsStrategy, disableDebug, dividerBuiltInStyles, doesMismatchMessageSchema, enableDebug, extractLeafLinksReferencedFromExperience, extractPrebindingDataByPatternId, extractReferencesFromEntries, extractReferencesFromEntriesAsIds, fetchAllAssets, fetchAllEntries, fetchById, fetchBySlug, fetchExperienceEntry, fetchReferencedEntities, findOutermostCoordinates, flattenDesignTokenRegistry, flattenNestedPatterns, gatherDeepPrebindingReferencesFromExperienceEntry, gatherDeepPrebindingReferencesFromPatternEntry, gatherDeepReferencesFromExperienceEntry, gatherDeepReferencesFromTree, generateDefaultDataSourceForPrebindingDefinition, generateRandomId, getActiveBreakpointIndex, getBreakpointRegistration, getDataFromTree, getDesignTokenRegistration, getElementCoordinates, getFallbackBreakpointIndex, getPrebindingPathBySourceEntry, getSdkOptions, getTargetPatternMappingsForParameter, getTargetValueInPixels, getTemplateValue, getValueForBreakpoint, inMemoryEntities, inMemoryEntitiesStore, indexByBreakpoint, isArrayOfLinks, isAsset, isCfStyleAttribute, isComponentAllowedOnRoot, isContentfulComponent, isContentfulStructureComponent, isDeepPath, isDeepPrebinding, isElementHidden, isEntry, isExperienceEntry, isLink, isLinkToAsset, isLinkToEntry, isPatternComponent, isPatternEntry, isPreboundProp, isStructureWithRelativeHeight, isValidBreakpointValue, lastPathNamedSegmentEq, localizeEntity, maybePopulateDesignTokenValue, mediaQueryMatcher, mergeDesignValuesByBreakpoint, optionalBuiltInStyles, parseCSSValue, parseDataSourcePathIntoFieldset, parseDataSourcePathWithL1DeepBindings, referencesOf, resetBreakpointsRegistry, resetDesignTokenRegistry, resolveBackgroundImageBinding, resolveHyperlinkPattern, runBreakpointsValidation, sanitizeNodeProps, sdkOptionsRegistry, sectionBuiltInStyles, sendMessage, setDebugLevel, singleColumnBuiltInStyles, splitDirectAndSlotChildren, stringifyCssProperties, toCSSAttribute, toMediaQuery, transformBoundContentValue, transformVisibility, treeMap, treeVisit, tryParseMessage, uniqueById, useInMemoryEntities, validateExperienceBuilderConfig };
 //# sourceMappingURL=index.js.map