@contentful/experiences-core 1.9.0-dev-20240628T2235-7a4f71f.0 → 1.9.0

package/dist/registries/breakpointsRegistry.d.ts

@@ -0,0 +1,20 @@
+import { Breakpoint } from '@contentful/experiences-validators';
+
+declare let breakpointsRegistry: Breakpoint[];
+/**
+ * Register custom breakpoints
+ * @param breakpoints - [{[key:string]: string}]
+ * @returns void
+ */
+declare const defineBreakpoints: (breakpoints: Breakpoint[]) => void;
+declare const runBreakpointsValidation: () => void;
+declare const getBreakpointRegistration: (id: string) => {
+    id: string;
+    displayName: string;
+    query: string;
+    previewSize: string;
+    displayIcon?: "desktop" | "tablet" | "mobile" | undefined;
+} | undefined;
+declare const resetBreakpointsRegistry: () => void;
+
+export { breakpointsRegistry, defineBreakpoints, getBreakpointRegistration, resetBreakpointsRegistry, runBreakpointsValidation };

package/dist/registries/designTokenRegistry.d.ts

@@ -0,0 +1,13 @@
+import { DesignTokensDefinition } from '../types.js';
+
+declare let designTokensRegistry: DesignTokensDefinition;
+/**
+ * Register design tokens styling
+ * @param designTokenDefinition - {[key:string]: Record<string, string>}
+ * @returns void
+ */
+declare const defineDesignTokens: (designTokenDefinition: DesignTokensDefinition) => void;
+declare const getDesignTokenRegistration: (breakpointValue: string, variableName: string) => string;
+declare const resetDesignTokenRegistry: () => void;
+
+export { defineDesignTokens, designTokensRegistry, getDesignTokenRegistration, resetDesignTokenRegistry };

package/dist/types.d.ts

@@ -0,0 +1,451 @@
+import { Entry, Asset, AssetFile } from 'contentful';
+import { SCROLL_STATES, OUTGOING_EVENTS, INCOMING_EVENTS, INTERNAL_EVENTS } from './constants.js';
+import { EntityStore } from './entity/EntityStore.js';
+import { Document } from '@contentful/rich-text-types';
+import { ComponentDefinitionPropertyType, ComponentPropertyValue, ExperienceDataSource, ExperienceUnboundValues, Breakpoint, ExperienceComponentTree, ExperienceUsedComponents, ExperienceComponentSettings, ValuesByBreakpoint, PrimitiveValue } from '@contentful/experiences-validators';
+export { BoundValue, Breakpoint, ComponentDefinitionPropertyType as ComponentDefinitionVariableType, ComponentPropertyValue, ComponentTreeNode, ComponentValue, DesignValue, ExperienceComponentSettings, ExperienceDataSource, ExperienceUnboundValues, PrimitiveValue, SchemaVersions, UnboundValue, ValuesByBreakpoint } from '@contentful/experiences-validators';
+
+type ScrollStateKey = keyof typeof SCROLL_STATES;
+type ScrollState = (typeof SCROLL_STATES)[ScrollStateKey];
+type OutgoingEventKey = keyof typeof OUTGOING_EVENTS;
+type OutgoingEvent = (typeof OUTGOING_EVENTS)[OutgoingEventKey];
+type IncomingEventKey = keyof typeof INCOMING_EVENTS;
+type IncomingEvent = (typeof INCOMING_EVENTS)[IncomingEventKey];
+type InternalEventKey = keyof typeof INTERNAL_EVENTS;
+type InternalEvent = (typeof INTERNAL_EVENTS)[InternalEventKey];
+interface Link<T extends string> {
+    sys: {
+        type: 'Link';
+        linkType: T;
+        id: string;
+    };
+}
+type VariableFormats = 'URL';
+type ValidationOption<T extends ComponentDefinitionPropertyType> = {
+    value: T extends 'Text' ? string : T extends 'Number' ? number : never;
+    displayName?: string;
+};
+type ComponentDefinitionVariableValidation<T extends ComponentDefinitionPropertyType> = {
+    required?: boolean;
+    in?: ValidationOption<T>[];
+    format?: VariableFormats;
+};
+interface ComponentDefinitionVariableBase<T extends ComponentDefinitionPropertyType> {
+    type: T;
+    validations?: ComponentDefinitionVariableValidation<T>;
+    group?: 'style' | 'content';
+    description?: string;
+    displayName?: string;
+    defaultValue?: string | boolean | number | Record<any, any>;
+}
+type ComponentDefinitionVariable<T extends ComponentDefinitionPropertyType = ComponentDefinitionPropertyType> = ComponentDefinitionVariableBase<T>;
+type ComponentDefinition<T extends ComponentDefinitionPropertyType = ComponentDefinitionPropertyType> = {
+    id: string;
+    name: string;
+    category?: string;
+    thumbnailUrl?: string;
+    hyperlinkPattern?: string;
+    variables: Partial<Record<ContainerStyleVariableName, ComponentDefinitionVariable<T>>> & Record<string, ComponentDefinitionVariable<T>>;
+    slots?: Record<string, {
+        displayName: string;
+    }>;
+    builtInStyles?: Array<keyof Omit<StyleProps, 'cfHyperlink' | 'cfOpenInNewTab'>>;
+    children?: boolean;
+    tooltip?: {
+        imageUrl?: string;
+        description: string;
+    };
+};
+type ComponentRegistration = {
+    component: React.ElementType;
+    definition: ComponentDefinition;
+    options?: {
+        wrapComponent?: boolean;
+        /** @deprecated use wrapContainer instead */
+        wrapContainerTag?: keyof JSX.IntrinsicElements;
+        wrapContainer?: keyof JSX.IntrinsicElements | React.ReactElement;
+    };
+};
+type ComponentRegistrationOptions = {
+    enabledBuiltInComponents?: string[];
+};
+type Binding = {
+    spaceId: string;
+    environmentId: string;
+    entityId: string;
+    entityType: 'Entry' | 'Asset' | 'ContentType';
+    path: string[];
+};
+type ComponentBinding = Record<string, Binding>;
+type BindingMap = Record<string, ComponentBinding>;
+type BindingMapByBlockId = Record<string, BindingMap>;
+type DataSourceEntryValueType = Link<'Entry' | 'Asset'>;
+/** Type of a single node of the experience tree exchanged via postMessage between the SDK and Contentful Web app */
+type ExperienceTreeNode = {
+    type: 'block' | 'root' | 'editorRoot' | 'designComponent' | 'designComponentBlock' | 'assembly' | 'assemblyBlock';
+    data: {
+        id: string;
+        blockId?: string;
+        slotId?: string;
+        assembly?: {
+            id: string;
+            componentId: string;
+            nodeLocation: string | null;
+        };
+        displayName?: string;
+        props: Record<string, ComponentPropertyValue>;
+        dataSource: ExperienceDataSource;
+        unboundValues: ExperienceUnboundValues;
+        breakpoints: Breakpoint[];
+    };
+    children: ExperienceTreeNode[];
+    parentId?: string;
+};
+/** Type of the tree data structure exchanged via postMessage between the SDK and Contentful Web app */
+type ExperienceTree = {
+    root: ExperienceTreeNode;
+};
+type ExternalSDKMode = 'preview' | 'delivery';
+type InternalSDKMode = ExternalSDKMode | 'editor';
+/**
+ * Internally defined style variables are prefix with `cf` to avoid
+ * collisions with user defined variables.
+ */
+type StyleProps = {
+    cfHorizontalAlignment: 'start' | 'end' | 'center';
+    cfVerticalAlignment: 'start' | 'end' | 'center';
+    cfMargin: string;
+    cfPadding: string;
+    cfBackgroundColor: string;
+    cfWidth: string;
+    cfMaxWidth: string;
+    cfHeight: string;
+    cfFlexDirection: 'row' | 'column';
+    cfFlexWrap: 'nowrap' | 'wrap';
+    cfBorder: string;
+    cfBorderRadius: string;
+    cfGap: string;
+    cfHyperlink: string;
+    cfImageAsset: OptimizedImageAsset | string;
+    cfImageOptions: ImageOptions;
+    cfBackgroundImageUrl: OptimizedBackgroundImageAsset | string;
+    cfBackgroundImageOptions: BackgroundImageOptions;
+    cfOpenInNewTab: boolean;
+    cfFontSize: string;
+    cfFontWeight: string;
+    cfLineHeight: string;
+    cfLetterSpacing: string;
+    cfTextColor: string;
+    cfTextAlign: 'left' | 'center' | 'right';
+    cfTextTransform: 'none' | 'capitalize' | 'uppercase' | 'lowercase';
+    cfTextBold: boolean;
+    cfTextItalic: boolean;
+    cfTextUnderline: boolean;
+    cfColumns: string;
+    cfColumnSpan: string;
+    cfColumnSpanLock: boolean;
+    cfWrapColumns: boolean;
+    cfWrapColumnsCount: string;
+};
+type CSSProperties = React.CSSProperties;
+type ContainerStyleVariableName = keyof StyleProps;
+type ExperienceFields = {
+    title: string;
+    slug: string;
+    componentTree: ExperienceComponentTree;
+    dataSource: ExperienceDataSource;
+    unboundValues: ExperienceUnboundValues;
+    usedComponents?: ExperienceUsedComponents | Array<ExperienceEntry>;
+    componentSettings?: ExperienceComponentSettings;
+};
+type RecursiveDesignTokenDefinition = {
+    [key: string]: string | RecursiveDesignTokenDefinition;
+};
+type DesignTokensDefinition = {
+    spacing?: Record<string, string>;
+    sizing?: Record<string, string>;
+    color?: Record<string, string>;
+    border?: Record<string, {
+        width?: string;
+        style?: 'solid' | 'dashed' | 'dotted';
+        color?: string;
+    }>;
+    borderRadius?: Record<string, string>;
+    fontSize?: Record<string, string>;
+    lineHeight?: Record<string, string>;
+    letterSpacing?: Record<string, string>;
+    textColor?: Record<string, string>;
+} & RecursiveDesignTokenDefinition;
+/** Type of experience entry JSON data structure as returned by CPA/CDA */
+type ExperienceEntry = {
+    sys: Entry['sys'];
+    fields: ExperienceFields;
+    metadata: Entry['metadata'];
+};
+interface RawCoordinates {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface Coordinates extends RawCoordinates {
+    childrenCoordinates: RawCoordinates[];
+}
+interface HoveredElement {
+    blockType: string | undefined;
+    nodeId: string | undefined;
+    blockId: string | undefined;
+}
+interface Experience<T extends EntityStore = EntityStore> {
+    hyperlinkPattern?: string;
+    entityStore?: T;
+}
+type ResolveDesignValueType = (valuesByBreakpoint: ValuesByBreakpoint, variableName: string) => PrimitiveValue;
+type ManagementEntity = (Entry | Asset) & {
+    sys: {
+        version: number;
+    };
+};
+type RequestEntitiesMessage = {
+    entityIds: string[];
+    entityType: 'Asset' | 'Entry';
+    locale: string;
+};
+type RequestedEntitiesMessage = {
+    entities: Array<Entry | Asset>;
+    missingEntityIds?: string[];
+};
+type BoundComponentPropertyTypes = string | number | boolean | AssetFile | Record<string, AssetFile | undefined> | Document | OptimizedBackgroundImageAsset | OptimizedImageAsset | Link<'Asset'> | undefined;
+type OptimizedImageAsset = {
+    url: string;
+    srcSet?: string[];
+    sizes?: string;
+    quality?: number;
+    format?: string;
+    file: AssetFile;
+    loading?: ImageLoadingOption;
+};
+type OptimizedBackgroundImageAsset = {
+    url: string;
+    srcSet?: string[];
+    file: AssetFile;
+};
+type ImageObjectFitOption = 'contain' | 'cover' | 'none';
+type ImageObjectPositionOption = 'left' | 'right' | 'top' | 'bottom' | 'left top' | 'left center' | 'left bottom' | 'right top' | 'right center' | 'right bottom' | 'center top' | 'center center' | 'center bottom';
+type ImageLoadingOption = 'lazy' | 'eager';
+type ImageOptions = {
+    format?: string;
+    width: string;
+    height: string;
+    loading?: ImageLoadingOption;
+    objectFit?: ImageObjectFitOption;
+    objectPosition?: ImageObjectPositionOption;
+    quality?: string;
+    targetSize: string;
+};
+type BackgroundImageScalingOption = 'fit' | 'fill' | 'tile';
+type BackgroundImageAlignmentOption = 'left' | 'right' | 'top' | 'bottom' | 'left top' | 'left center' | 'left bottom' | 'right top' | 'right center' | 'right bottom' | 'center top' | 'center center' | 'center bottom';
+type BackgroundImageOptions = {
+    format?: string;
+    scaling: BackgroundImageScalingOption;
+    alignment: BackgroundImageAlignmentOption;
+    quality?: string;
+    targetSize: string;
+};
+interface DraggableProvidedDraggableProps {
+    'data-rfd-draggable-context-id'?: string;
+    'data-rfd-draggable-id'?: string;
+}
+interface DraggableProvidedDragHandleProps {
+    'data-rfd-drag-handle-draggable-id'?: string;
+    'data-rfd-drag-handle-context-id'?: string;
+}
+type WrapperTags = keyof Pick<JSX.IntrinsicElements, 'div' | 'span' | 'section' | 'article' | 'aside' | 'p' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'header' | 'footer' | 'nav' | 'main'>;
+interface DragWrapperProps extends DraggableProvidedDragHandleProps, DraggableProvidedDraggableProps, React.HTMLAttributes<HTMLElement>, React.PropsWithChildren {
+    'data-cf-node-id'?: string;
+    'data-ctfl-draggable-id'?: string;
+    'data-test-id'?: string;
+    'data-cf-node-block-id'?: string;
+    'data-cf-node-block-type'?: string;
+    'data-ctfl-dragging-element'?: string;
+    innerRef?: (refNode: HTMLElement) => void;
+    wrapComponent?: boolean;
+    Tag?: WrapperTags;
+    ToolTipAndPlaceholder?: React.ReactNode;
+}
+type ConnectedPayload = undefined | {
+    sdkVersion: string;
+    definitions: ComponentDefinition[];
+};
+type DesignTokensPayload = {
+    designTokens: DesignTokensDefinition;
+    resolvedCssVariables: Record<string, string>;
+};
+type RegisteredBreakpointsPayload = {
+    breakpoints: Breakpoint[];
+};
+type MouseMovePayload = {
+    clientX: number;
+    clientY: number;
+};
+type NewHoveredElementPayload = {
+    nodeId?: string;
+};
+type ComponentSelectedPayload = {
+    nodeId: string;
+    assembly?: {
+        id: string;
+        componentId: string;
+        nodeLocation: string | null;
+    };
+};
+type RegisteredComponentsPayload = {
+    definitions: ComponentDefinition[];
+};
+type RequestComponentTreeUpdatePayload = undefined;
+type ComponentDragCanceledPayload = undefined;
+type ComponentDroppedPayload = {
+    node: ExperienceTreeNode;
+    index: number;
+    parentNode: {
+        type?: ExperienceTreeNode['type'] | 'root';
+        data: {
+            blockId?: string;
+            id?: string;
+        };
+    };
+};
+type ComponentMovedPayload = {
+    nodeId: string;
+    sourceParentId: string;
+    destinationParentId: string;
+    sourceIndex: number;
+    destinationIndex: number;
+};
+type CanvasReloadPayload = undefined;
+type CanvasErrorPayload = Error;
+type UpdateSelectedComponentCoordinatesPayload = {
+    selectedNodeCoordinates: DOMRect;
+    selectedAssemblyChildCoordinates?: DOMRect;
+    parentCoordinates?: DOMRect;
+};
+type CanvasScrollPayload = (typeof SCROLL_STATES)[keyof typeof SCROLL_STATES];
+type ComponentMoveStartedPayload = undefined;
+type ComponentMoveEndedPayload = undefined;
+type OutsideCanvasClickPayload = {
+    outsideCanvasClick: boolean;
+};
+type SDKFeaturesPayload = Record<string, unknown>;
+type RequestEntitiesPayload = {
+    entityIds: string[];
+    entityType: 'Entry' | 'Asset';
+    locale: string;
+};
+type OUTGOING_EVENT_PAYLOADS = {
+    connected: ConnectedPayload;
+    registerDesignTokens: DesignTokensPayload;
+    registeredBreakpoints: RegisteredBreakpointsPayload;
+    mouseMove: MouseMovePayload;
+    newHoveredElement: NewHoveredElementPayload;
+    componentSelected: ComponentSelectedPayload;
+    registeredComponents: RegisteredComponentsPayload;
+    requestComponentTreeUpdate: RequestComponentTreeUpdatePayload;
+    componentDragCanceled: ComponentDragCanceledPayload;
+    componentDropped: ComponentDroppedPayload;
+    componentMoved: ComponentMovedPayload;
+    canvasReload: CanvasReloadPayload;
+    canvasError: CanvasErrorPayload;
+    updateSelectedComponentCoordinates: UpdateSelectedComponentCoordinatesPayload;
+    canvasScrolling: CanvasScrollPayload;
+    componentMoveStarted: ComponentMoveStartedPayload;
+    componentMoveEnded: ComponentMoveEndedPayload;
+    outsideCanvasClick: OutsideCanvasClickPayload;
+    sdkFeatures: SDKFeaturesPayload;
+    REQUEST_ENTITIES: RequestEntitiesPayload;
+};
+type SendMessageParams = <T extends OutgoingEvent>(eventType: T, data: OUTGOING_EVENT_PAYLOADS[T]) => void;
+type OutgoingMessage = {
+    [K in keyof OUTGOING_EVENT_PAYLOADS]: {
+        source: 'customer-app';
+        eventType: K;
+        payload: OUTGOING_EVENT_PAYLOADS[K];
+    };
+}[keyof OUTGOING_EVENT_PAYLOADS];
+type Filter<T, U> = T extends U ? T : never;
+type SelectedValueTypes = Filter<ComponentPropertyValue['type'], 'UnboundValue' | 'BoundValue'>;
+type RequestEditorModePayload = undefined;
+type ExperienceUpdatedPayload = {
+    tree: ExperienceTree;
+    /** @deprecated in favor of assemblies */
+    designComponents?: ExperienceUsedComponents;
+    assemblies?: ExperienceUsedComponents;
+    locale: string;
+    /** @deprecated maybe? */
+    defaultLocaleCode?: string;
+    changedNode?: ExperienceTreeNode;
+    changedValueType?: SelectedValueTypes;
+};
+type ComponentDraggingChangedPayload = {
+    isDragging: boolean;
+};
+type IncomingComponentDragCanceledPayload = undefined;
+type ComponentDragStartedPayload = {
+    id: string;
+};
+type ComponentDragEndedPayload = undefined;
+type IncomingComponentMoveEndedPayload = {
+    mouseX: number;
+    mouseY: number;
+};
+type CanvasResizedPayload = {
+    selectedNodeId: string;
+};
+type SelectComponentPayload = {
+    selectedNodeId: string;
+};
+type HoverComponentPayload = {
+    hoveredNodeId: string;
+};
+type UpdatedEntityPayload = {
+    entity: ManagementEntity;
+    shouldRerender?: boolean;
+};
+type AssembliesAddedPayload = {
+    assembly: ManagementEntity;
+    assemblyDefinition: ComponentDefinition;
+};
+type AssembliesRegisteredPayload = {
+    assemblies: ComponentDefinition[];
+};
+type IncomingMouseMovePayload = {
+    mouseX: number;
+    mouseY: number;
+};
+type RequestedEntitiesPayload = {
+    entities: ManagementEntity[];
+};
+type INCOMING_EVENT_PAYLOADS = {
+    requestEditorMode: RequestEditorModePayload;
+    componentTreeUpdated: ExperienceUpdatedPayload;
+    componentDraggingChanged: ComponentDraggingChangedPayload;
+    componentDragCanceled: IncomingComponentDragCanceledPayload;
+    componentDragStarted: ComponentDragStartedPayload;
+    componentDragEnded: ComponentDragEndedPayload;
+    componentMoveEnded: IncomingComponentMoveEndedPayload;
+    canvasResized: CanvasResizedPayload;
+    selectComponent: SelectComponentPayload;
+    hoverComponent: HoverComponentPayload;
+    updatedEntity: UpdatedEntityPayload;
+    assembliesAdded: AssembliesAddedPayload;
+    assembliesRegistered: AssembliesRegisteredPayload;
+    mouseMove: IncomingMouseMovePayload;
+    REQUESTED_ENTITIES: RequestedEntitiesPayload;
+};
+type IncomingMessage = {
+    [K in keyof INCOMING_EVENT_PAYLOADS]: {
+        eventType: K;
+        payload: INCOMING_EVENT_PAYLOADS[K];
+    };
+}[keyof INCOMING_EVENT_PAYLOADS];
+
+export type { AssembliesAddedPayload, AssembliesRegisteredPayload, BackgroundImageAlignmentOption, BackgroundImageOptions, BackgroundImageScalingOption, Binding, BindingMap, BindingMapByBlockId, BoundComponentPropertyTypes, CSSProperties, CanvasErrorPayload, CanvasReloadPayload, CanvasResizedPayload, CanvasScrollPayload, ComponentBinding, ComponentDefinition, ComponentDefinitionVariable, ComponentDefinitionVariableBase, ComponentDefinitionVariableValidation, ComponentDragCanceledPayload, ComponentDragEndedPayload, ComponentDragStartedPayload, ComponentDraggingChangedPayload, ComponentDroppedPayload, ComponentMoveEndedPayload, ComponentMoveStartedPayload, ComponentMovedPayload, ComponentRegistration, ComponentRegistrationOptions, ComponentSelectedPayload, ConnectedPayload, ContainerStyleVariableName, Coordinates, DataSourceEntryValueType, DesignTokensDefinition, DesignTokensPayload, DragWrapperProps, Experience, ExperienceEntry, ExperienceFields, ExperienceTree, ExperienceTreeNode, ExperienceUpdatedPayload, ExternalSDKMode, HoverComponentPayload, HoveredElement, ImageLoadingOption, ImageObjectFitOption, ImageObjectPositionOption, ImageOptions, IncomingComponentDragCanceledPayload, IncomingComponentMoveEndedPayload, IncomingEvent, IncomingMessage, IncomingMouseMovePayload, InternalEvent, InternalSDKMode, Link, ManagementEntity, MouseMovePayload, NewHoveredElementPayload, OptimizedBackgroundImageAsset, OptimizedImageAsset, OutgoingEvent, OutgoingMessage, OutsideCanvasClickPayload, RawCoordinates, RecursiveDesignTokenDefinition, RegisteredBreakpointsPayload, RegisteredComponentsPayload, RequestComponentTreeUpdatePayload, RequestEditorModePayload, RequestEntitiesMessage, RequestEntitiesPayload, RequestedEntitiesMessage, RequestedEntitiesPayload, ResolveDesignValueType, SDKFeaturesPayload, ScrollState, SelectComponentPayload, SendMessageParams, StyleProps, UpdateSelectedComponentCoordinatesPayload, UpdatedEntityPayload, ValidationOption, VariableFormats, WrapperTags };

package/dist/utils/breakpoints.d.ts

@@ -0,0 +1,12 @@
+import { Breakpoint, ValuesByBreakpoint } from '@contentful/experiences-validators';
+
+declare const MEDIA_QUERY_REGEXP: RegExp;
+declare const mediaQueryMatcher: (breakpoints: Breakpoint[]) => [{
+    id: string;
+    signal: MediaQueryList;
+}[], Record<string, boolean>];
+declare const getActiveBreakpointIndex: (breakpoints: Breakpoint[], mediaQueryMatches: Record<string, boolean>, fallbackBreakpointIndex: number) => number;
+declare const getFallbackBreakpointIndex: (breakpoints: Breakpoint[]) => number;
+declare const getValueForBreakpoint: (valuesByBreakpoint: ValuesByBreakpoint, breakpoints: Breakpoint[], activeBreakpointIndex: number, variableName: string) => string | number | boolean | Record<any, any> | undefined;
+
+export { MEDIA_QUERY_REGEXP, getActiveBreakpointIndex, getFallbackBreakpointIndex, getValueForBreakpoint, mediaQueryMatcher };

package/dist/utils/components.d.ts

@@ -0,0 +1,5 @@
+declare const isContentfulStructureComponent: (componentId?: string) => boolean;
+declare const isComponentAllowedOnRoot: (componentId?: string) => boolean;
+declare const isStructureWithRelativeHeight: (componentId?: string, height?: string | number) => boolean;
+
+export { isComponentAllowedOnRoot, isContentfulStructureComponent, isStructureWithRelativeHeight };

package/dist/utils/domValues.d.ts

@@ -0,0 +1,15 @@
+type Rect = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare const findOutermostCoordinates: (first: Rect, second: Rect) => {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare const getElementCoordinates: (element: Element) => DOMRect;
+
+export { findOutermostCoordinates, getElementCoordinates };

package/dist/utils/isLink.d.ts

@@ -0,0 +1,5 @@
+import { UnresolvedLink, Entry, Asset } from 'contentful';
+
+declare const isLink: (maybeLink: UnresolvedLink<"Entry" | "Asset"> | Entry | Asset | string | unknown) => maybeLink is UnresolvedLink<"Entry" | "Asset">;
+
+export { isLink };

package/dist/utils/isLinkToAsset.d.ts

@@ -0,0 +1,5 @@
+import { Link } from '../types.js';
+
+declare const isLinkToAsset: (variable: any) => variable is Link<"Asset">;
+
+export { isLinkToAsset };

package/dist/utils/pathSchema.d.ts

@@ -0,0 +1,31 @@
+import { Entry, Asset } from 'contentful';
+
+/**
+ * This module encapsulates format of the path to a deep reference.
+ */
+
+type UnresolvedFieldset = Array<[null, string, string?]>;
+type Fieldset = Array<[Entry | Asset, string, string?]>;
+declare const parseDataSourcePathIntoFieldset: (path: string) => UnresolvedFieldset;
+/**
+ * Parse path into components, supports  L1 references (one reference follow) atm.
+ * @param path from data source. eg. `/uuid123/fields/image/~locale/fields/file/~locale`
+ *                               eg. `/uuid123/fields/file/~locale/fields/title/~locale`
+ * @returns
+ */
+declare const parseDataSourcePathWithL1DeepBindings: (path: string) => {
+    key: string;
+    field: string;
+    referentField: string;
+};
+/**
+ * Detects if paths is valid deep-path, like:
+ *  - /gV6yKXp61hfYrR7rEyKxY/fields/mainStory/~locale/fields/cover/~locale/fields/title/~locale
+ * or regular, like:
+ *  - /6J8eA60yXwdm5eyUh9fX6/fields/mainStory/~locale
+ * @returns
+ */
+declare const isDeepPath: (deepPathCandidate: string) => boolean;
+declare const lastPathNamedSegmentEq: (path: string, expectedName: string) => boolean;
+
+export { type Fieldset, type UnresolvedFieldset, isDeepPath, lastPathNamedSegmentEq, parseDataSourcePathIntoFieldset, parseDataSourcePathWithL1DeepBindings };

package/dist/utils/resolveHyperlinkPattern.d.ts

@@ -0,0 +1,17 @@
+import { Entry } from 'contentful';
+
+declare const resolveHyperlinkPattern: (pattern: string, entry: Entry | null, locale: string | null) => string | null;
+declare function addLocale(str: string, locale: string): string;
+declare function getTemplateValue(ctx: {
+    entry: Entry;
+    locale: string;
+}, path: string): string | (() => string);
+declare function buildTemplate({ template, context, }: {
+    template: string;
+    context: {
+        entry: Entry;
+        locale: string;
+    };
+}): string;
+
+export { addLocale, buildTemplate, getTemplateValue, resolveHyperlinkPattern };

package/dist/utils/styleUtils/ssrStyles.d.ts

@@ -0,0 +1,51 @@
+import { Entry, Asset } from 'contentful/dist/types/types';
+import { ComponentPropertyValue, ExperienceUnboundValues, ExperienceDataSource, ExperienceComponentSettings } from '@contentful/experiences-validators';
+import { Experience, StyleProps, DesignTokensDefinition } from '../../types.js';
+
+type FlattenedDesignTokens = Record<string, string | {
+    width?: string;
+    style?: string;
+    color?: string;
+}>;
+declare const detachExperienceStyles: (experience: Experience) => string | undefined;
+declare const isCfStyleAttribute: (variableName: string) => variableName is keyof StyleProps;
+declare const maybePopulateDesignTokenValue: (variableName: string, variableValue: unknown, mapOfDesignVariableKeys: FlattenedDesignTokens) => unknown;
+declare const resolveBackgroundImageBinding: ({ variableData, getBoundEntityById, dataSource, unboundValues, componentVariablesOverwrites, componentSettings, }: {
+    variableData: ComponentPropertyValue;
+    getBoundEntityById: (id: string) => Entry | Asset | undefined;
+    unboundValues?: ExperienceUnboundValues;
+    dataSource?: ExperienceDataSource;
+    componentSettings?: ExperienceComponentSettings;
+    componentVariablesOverwrites?: Record<string, ComponentPropertyValue>;
+}) => string | undefined;
+declare const indexByBreakpoint: ({ variables, breakpointIds, getBoundEntityById, unboundValues, dataSource, componentVariablesOverwrites, componentSettings, }: {
+    variables: Record<string, ComponentPropertyValue>;
+    breakpointIds: string[];
+    getBoundEntityById: (id: string) => Entry | Asset | undefined;
+    unboundValues?: ExperienceUnboundValues;
+    dataSource?: ExperienceDataSource;
+    componentVariablesOverwrites?: Record<string, ComponentPropertyValue>;
+    componentSettings?: ExperienceComponentSettings;
+}) => Record<string, Record<string, unknown>>;
+/**
+ * Flattens the object from
+ * {
+ *   color: {
+ *      [key]: [value]
+ *   }
+ * }
+ *
+ * to
+ *
+ * {
+ *  'color.key': [value]
+ * }
+ */
+declare const flattenDesignTokenRegistry: (designTokenRegistry: DesignTokensDefinition) => FlattenedDesignTokens;
+declare const toCSSString: (breakpointStyles: Record<string, string>) => string;
+declare const toMediaQuery: (breakpointPayload: {
+    condition: string;
+    cssByClassName: Record<string, string>;
+}) => string;
+
+export { detachExperienceStyles, flattenDesignTokenRegistry, indexByBreakpoint, isCfStyleAttribute, maybePopulateDesignTokenValue, resolveBackgroundImageBinding, toCSSString, toMediaQuery };

package/dist/utils/styleUtils/stylesUtils.d.ts

@@ -0,0 +1,21 @@
+import { CSSProperties, StyleProps, ExperienceTreeNode } from '../../types.js';
+import { PrimitiveValue } from '@contentful/experiences-validators';
+
+declare const toCSSAttribute: (key: string) => string;
+declare const buildStyleTag: ({ styles, nodeId }: {
+    styles: CSSProperties;
+    nodeId?: string;
+}) => string[];
+declare const buildCfStyles: ({ cfHorizontalAlignment, cfVerticalAlignment, cfFlexDirection, cfFlexWrap, cfMargin, cfPadding, cfBackgroundColor, cfWidth, cfHeight, cfMaxWidth, cfBorder, cfBorderRadius, cfGap, cfBackgroundImageUrl, cfBackgroundImageOptions, cfFontSize, cfFontWeight, cfImageOptions, cfLineHeight, cfLetterSpacing, cfTextColor, cfTextAlign, cfTextTransform, cfTextBold, cfTextItalic, cfTextUnderline, cfColumnSpan, }: Partial<StyleProps>) => CSSProperties;
+/**
+ * Container/section default behavior:
+ * Default height => height: EMPTY_CONTAINER_HEIGHT
+ * If a container component has children => height: 'fit-content'
+ */
+declare const calculateNodeDefaultHeight: ({ blockId, children, value, }: {
+    blockId?: string;
+    children: ExperienceTreeNode["children"];
+    value: PrimitiveValue;
+}) => string | number | boolean | Record<any, any> | undefined;
+
+export { buildCfStyles, buildStyleTag, calculateNodeDefaultHeight, toCSSAttribute };

package/dist/utils/supportedModes.d.ts

@@ -0,0 +1,5 @@
+import { InternalSDKMode } from '../types.js';
+
+declare const supportedModes: InternalSDKMode[];
+
+export { supportedModes };

package/dist/utils/transformers/transformBoundContentValue.d.ts

@@ -0,0 +1,8 @@
+import { ResolveDesignValueType, ComponentDefinitionVariable, BoundComponentPropertyTypes } from '../../types.js';
+import { UnresolvedLink } from 'contentful';
+import { EntityStoreBase } from '../../entity/EntityStoreBase.js';
+import { ComponentTreeNode } from '@contentful/experiences-validators';
+
+declare const transformBoundContentValue: (variables: ComponentTreeNode["variables"], entityStore: EntityStoreBase, binding: UnresolvedLink<"Entry" | "Asset">, resolveDesignValue: ResolveDesignValueType, variableName: string, variableDefinition: ComponentDefinitionVariable, path: string) => BoundComponentPropertyTypes;
+
+export { transformBoundContentValue };