@sitecore-content-sdk/react 1.3.0-canary.9 → 1.4.0-canary.2

package/dist/esm/components/Text.js

@@ -1,59 +1,63 @@
-'use client';
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import React from 'react';
-import { withFieldMetadata } from '../enhancers/withFieldMetadata';
-import { withEmptyFieldEditingComponent } from '../enhancers/withEmptyFieldEditingComponent';
-import { DefaultEmptyFieldEditingComponentText } from './DefaultEmptyFieldEditingComponents';
-import { isFieldValueEmpty } from '@sitecore-content-sdk/core/layout';
-export const Text = withFieldMetadata(withEmptyFieldEditingComponent((_a) => {
-    var { field, tag, editable = true, encode = true } = _a, otherProps = __rest(_a, ["field", "tag", "editable", "encode"]);
-    if (isFieldValueEmpty(field)) {
-        return null;
-    }
-    // can't use editable value if we want to output unencoded
-    if (!encode) {
-        // eslint-disable-next-line no-param-reassign, no-unused-vars
-        editable = false;
-    }
-    let output = field.value === undefined ? '' : field.value;
-    // when string value isn't formatted, we should format line breaks
-    const splitted = String(output).split('\n');
-    if (splitted.length) {
-        const formatted = [];
-        splitted.forEach((str, i) => {
-            const isLast = i === splitted.length - 1;
-            formatted.push(str);
-            if (!isLast) {
-                formatted.push(React.createElement("br", { key: i }));
-            }
-        });
-        output = formatted;
-    }
-    let children = null;
-    const htmlProps = Object.assign({}, otherProps);
-    if (!encode) {
-        htmlProps.dangerouslySetInnerHTML = {
-            __html: output,
-        };
-    }
-    else {
-        children = output;
-    }
-    if (tag || !encode) {
-        return React.createElement(tag || 'span', htmlProps, children);
-    }
-    else {
-        return React.createElement(React.Fragment, null, children);
-    }
-}, { defaultEmptyFieldEditingComponent: DefaultEmptyFieldEditingComponentText }));
-Text.displayName = 'Text';
+'use client';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from 'react';
+import { withFieldMetadata } from '../enhancers/withFieldMetadata';
+import { withEmptyFieldEditingComponent } from '../enhancers/withEmptyFieldEditingComponent';
+import { DefaultEmptyFieldEditingComponentText } from './DefaultEmptyFieldEditingComponents';
+import { isFieldValueEmpty } from '@sitecore-content-sdk/core/layout';
+/**
+ * The Text component.
+ * @public
+ */
+export const Text = withFieldMetadata(withEmptyFieldEditingComponent((_a) => {
+    var { field, tag, editable = true, encode = true } = _a, otherProps = __rest(_a, ["field", "tag", "editable", "encode"]);
+    if (isFieldValueEmpty(field)) {
+        return null;
+    }
+    // can't use editable value if we want to output unencoded
+    if (!encode) {
+        // eslint-disable-next-line no-param-reassign, no-unused-vars
+        editable = false;
+    }
+    let output = field.value === undefined ? '' : field.value;
+    // when string value isn't formatted, we should format line breaks
+    const splitted = String(output).split('\n');
+    if (splitted.length) {
+        const formatted = [];
+        splitted.forEach((str, i) => {
+            const isLast = i === splitted.length - 1;
+            formatted.push(str);
+            if (!isLast) {
+                formatted.push(React.createElement("br", { key: i }));
+            }
+        });
+        output = formatted;
+    }
+    let children = null;
+    const htmlProps = Object.assign({}, otherProps);
+    if (!encode) {
+        htmlProps.dangerouslySetInnerHTML = {
+            __html: output,
+        };
+    }
+    else {
+        children = output;
+    }
+    if (tag || !encode) {
+        return React.createElement(tag || 'span', htmlProps, children);
+    }
+    else {
+        return React.createElement(React.Fragment, null, children);
+    }
+}, { defaultEmptyFieldEditingComponent: DefaultEmptyFieldEditingComponentText }));
+Text.displayName = 'Text';

package/dist/esm/components/sharedTypes/components.js

@@ -1,4 +1,4 @@
-/**
- * SXA uses custom default export name
- */
-export const DEFAULT_EXPORT_NAME = 'Default';
+/**
+ * SXA uses custom default export name
+ */
+export const DEFAULT_EXPORT_NAME = 'Default';

package/dist/esm/components/sharedTypes/index.js

@@ -1,2 +1,2 @@
-export * from './components';
-export * from './props';
+export * from './components';
+export * from './props';

package/dist/esm/components/sharedTypes/props.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/enhancers/withAppPlaceholder.js

@@ -1,14 +1,14 @@
-import React from 'react';
-import { AppPlaceholder } from '../components/Placeholder/AppPlaceholder';
-export const withAppPlaceholder = (Component) => {
-    return (props) => {
-        const placeholders = props.rendering.placeholders;
-        const phProps = {};
-        for (const placeholder of Object.keys(placeholders)) {
-            phProps[placeholder] = (React.createElement(AppPlaceholder, { name: placeholder, rendering: props.rendering, componentMap: props.componentMap, page: props.page }));
-        }
-        const displayName = Component.displayName || Component.name || 'Component';
-        const propsCopy = Object.assign(Object.assign({}, props), { displayName });
-        return React.createElement(Component, Object.assign({}, propsCopy, { placeholders: phProps }));
-    };
-};
+import React from 'react';
+import { AppPlaceholder } from '../components/Placeholder/AppPlaceholder';
+export const withAppPlaceholder = (Component) => {
+    return (props) => {
+        const placeholders = props.rendering.placeholders || {};
+        const phProps = {};
+        for (const placeholder of Object.keys(placeholders)) {
+            phProps[placeholder] = (React.createElement(AppPlaceholder, { name: placeholder, rendering: props.rendering, componentMap: props.componentMap, page: props.page }));
+        }
+        const displayName = Component.displayName || Component.name || 'Component';
+        const propsCopy = Object.assign(Object.assign({}, props), { displayName });
+        return React.createElement(Component, Object.assign({}, propsCopy, { placeholders: phProps }));
+    };
+};

package/dist/esm/enhancers/withComponentMap.js

@@ -1,18 +1,18 @@
-import React from 'react';
-import { ComponentMapReactContext } from '../components/SitecoreProvider';
-import { useContext } from 'react';
-/**
- * @param {React.ComponentClass<T> | React.FC<T>} Component
- */
-export function withComponentMap(Component) {
-    /**
-     * @param {T} props - props to pass to the wrapped component
-     * @returns {JSX.Element} - the rendered component
-     */
-    function WithComponentMap(props) {
-        const context = useContext(ComponentMapReactContext);
-        return React.createElement(Component, Object.assign({}, props, { componentMap: props.componentMap || context }));
-    }
-    WithComponentMap.displayName = `withComponentMap(${Component.displayName || Component.name || 'Anonymous'})`;
-    return WithComponentMap;
-}
+import React from 'react';
+import { ComponentMapReactContext } from '../components/SitecoreProvider';
+import { useContext } from 'react';
+/**
+ * @param {React.ComponentClass<T> | React.FC<T>} Component
+ */
+export function withComponentMap(Component) {
+    /**
+     * @param {T} props - props to pass to the wrapped component
+     * @returns {JSX.Element} - the rendered component
+     */
+    function WithComponentMap(props) {
+        const context = useContext(ComponentMapReactContext);
+        return React.createElement(Component, Object.assign({}, props, { componentMap: props.componentMap || context }));
+    }
+    WithComponentMap.displayName = `withComponentMap(${Component.displayName || Component.name || 'Anonymous'})`;
+    return WithComponentMap;
+}

package/dist/esm/enhancers/withDatasourceCheck.js

@@ -1,22 +1,23 @@
-import React from 'react';
-import { useSitecore } from './withSitecore';
-export const DefaultEditingError = () => (React.createElement("div", { className: "sc-jss-editing-error", role: "alert" }, "Datasource is required. Please choose a content item for this component."));
-/**
- * Checks whether a Sitecore datasource is present and renders appropriately depending on page mode (normal vs editing).
- * @param {WithDatasourceCheckOptions} [options]
- * @returns
- *  The wrapped component, if a datasource is present.
- *  A null component (in normal mode) or an error component (in editing mode), if a datasource is not present.
- */
-export function withDatasourceCheck(options) {
-    return function withDatasourceCheckHoc(Component) {
-        return function WithDatasourceCheck(props) {
-            var _a, _b;
-            const { page } = useSitecore();
-            const EditingError = (_a = options === null || options === void 0 ? void 0 : options.editingErrorComponent) !== null && _a !== void 0 ? _a : DefaultEditingError;
-            // If the component is rendered in DesignLibrary, we don't need to check for datasource
-            const isDesignLibrary = page.mode.isDesignLibrary;
-            return isDesignLibrary || ((_b = props.rendering) === null || _b === void 0 ? void 0 : _b.dataSource) ? (React.createElement(Component, Object.assign({}, props))) : page.mode.isEditing ? (React.createElement(EditingError, null)) : null;
-        };
-    };
-}
+import React from 'react';
+import { useSitecore } from './withSitecore';
+export const DefaultEditingError = () => (React.createElement("div", { className: "sc-jss-editing-error", role: "alert" }, "Datasource is required. Please choose a content item for this component."));
+/**
+ * Checks whether a Sitecore datasource is present and renders appropriately depending on page mode (normal vs editing).
+ * @param {WithDatasourceCheckOptions} [options]
+ * @returns
+ *  The wrapped component, if a datasource is present.
+ *  A null component (in normal mode) or an error component (in editing mode), if a datasource is not present.
+ * @public
+ */
+export function withDatasourceCheck(options) {
+    return function withDatasourceCheckHoc(Component) {
+        return function WithDatasourceCheck(props) {
+            var _a, _b;
+            const { page } = useSitecore();
+            const EditingError = (_a = options === null || options === void 0 ? void 0 : options.editingErrorComponent) !== null && _a !== void 0 ? _a : DefaultEditingError;
+            // If the component is rendered in DesignLibrary, we don't need to check for datasource
+            const isDesignLibrary = page.mode.isDesignLibrary;
+            return isDesignLibrary || ((_b = props.rendering) === null || _b === void 0 ? void 0 : _b.dataSource) ? (React.createElement(Component, Object.assign({}, props))) : page.mode.isEditing ? (React.createElement(EditingError, null)) : null;
+        };
+    };
+}

package/dist/esm/enhancers/withEditorChromes.js

@@ -1,17 +1,22 @@
-import React from 'react';
-import { resetEditorChromes } from '..';
-export const withEditorChromes = (WrappedComponent) => {
-    class Enhancer extends React.Component {
-        constructor() {
-            super(...arguments);
-            this.displayName = WrappedComponent.displayName || WrappedComponent.name || 'Component';
-        }
-        componentDidUpdate() {
-            resetEditorChromes();
-        }
-        render() {
-            return React.createElement(WrappedComponent, Object.assign({}, this.props));
-        }
-    }
-    return Enhancer;
-};
+import React from 'react';
+import { resetEditorChromes } from '..';
+/**
+ * HOC to inject editor chromes reset on component update.
+ * @param {React.ComponentClass<unknown> | React.FC<unknown>} WrappedComponent - The component to wrap.
+ * @public
+ */
+export const withEditorChromes = (WrappedComponent) => {
+    class Enhancer extends React.Component {
+        constructor() {
+            super(...arguments);
+            this.displayName = WrappedComponent.displayName || WrappedComponent.name || 'Component';
+        }
+        componentDidUpdate() {
+            resetEditorChromes();
+        }
+        render() {
+            return React.createElement(WrappedComponent, Object.assign({}, this.props));
+        }
+    }
+    return Enhancer;
+};

package/dist/esm/enhancers/withEmptyFieldEditingComponent.js

@@ -1,34 +1,35 @@
-import React, { forwardRef } from 'react';
-import { isFieldValueEmpty, } from '@sitecore-content-sdk/core/layout';
-/**
- * Returns the passed field component or default component in case field value is empty and edit mode is 'metadata'
- * @param {ComponentType<FieldComponentProps>} FieldComponent the field component
- * @param {WithEmptyFieldEditingComponentProps} options the options of the HOC;
- */
-export function withEmptyFieldEditingComponent(FieldComponent, options) {
-    const getEmptyFieldEditingComponent = (props) => {
-        var _a;
-        const { editable = true } = props;
-        if (((_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata) && editable && isFieldValueEmpty(props.field)) {
-            const Component = props.emptyFieldEditingComponent || options.defaultEmptyFieldEditingComponent;
-            let resolvedProps = props;
-            // If no custom empty field editing component is provided, we can omit unnecessary props
-            // to do not insert them to html
-            if (!props.emptyFieldEditingComponent) {
-                resolvedProps = Object.assign(Object.assign({}, props), { editable: undefined, field: undefined });
-            }
-            return React.createElement(Component, Object.assign({}, resolvedProps));
-        }
-        return null;
-    };
-    if (options.isForwardRef) {
-        return forwardRef((props, ref) => {
-            const emptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
-            return (emptyFieldEditingComponent || (React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }))));
-        });
-    }
-    return (props) => {
-        const emptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
-        return emptyFieldEditingComponent || React.createElement(FieldComponent, Object.assign({}, props));
-    };
-}
+import React, { forwardRef } from 'react';
+import { isFieldValueEmpty, } from '@sitecore-content-sdk/core/layout';
+/**
+ * Returns the passed field component or default component in case field value is empty and edit mode is 'metadata'
+ * @param {ComponentType<FieldComponentProps>} FieldComponent the field component
+ * @param {WithEmptyFieldEditingComponentProps} options the options of the HOC;
+ * @public
+ */
+export function withEmptyFieldEditingComponent(FieldComponent, options) {
+    const getEmptyFieldEditingComponent = (props) => {
+        var _a;
+        const { editable = true } = props;
+        if (((_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata) && editable && isFieldValueEmpty(props.field)) {
+            const Component = props.emptyFieldEditingComponent || options.defaultEmptyFieldEditingComponent;
+            let resolvedProps = props;
+            // If no custom empty field editing component is provided, we can omit unnecessary props
+            // to do not insert them to html
+            if (!props.emptyFieldEditingComponent) {
+                resolvedProps = Object.assign(Object.assign({}, props), { editable: undefined, field: undefined });
+            }
+            return React.createElement(Component, Object.assign({}, resolvedProps));
+        }
+        return null;
+    };
+    if (options.isForwardRef) {
+        return forwardRef((props, ref) => {
+            const emptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
+            return (emptyFieldEditingComponent || (React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }))));
+        });
+    }
+    return (props) => {
+        const emptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
+        return emptyFieldEditingComponent || React.createElement(FieldComponent, Object.assign({}, props));
+    };
+}

package/dist/esm/enhancers/withFieldMetadata.js

@@ -1,31 +1,32 @@
-import React, { forwardRef } from 'react';
-import { FieldMetadata } from '../components/FieldMetadata';
-/**
- * Wraps the field component with metadata markup intended to be used for chromes hydration in Pages
- * @param {ComponentType<FieldComponentProps>} FieldComponent the field component
- * @param {boolean} isForwardRef set to 'true' if forward reference is needed
- */
-export function withFieldMetadata(FieldComponent, isForwardRef = false) {
-    if (isForwardRef) {
-        return forwardRef((props, ref) => {
-            var _a;
-            const { editable = true } = props;
-            const metadata = (_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata;
-            if (!metadata || !editable) {
-                return React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }));
-            }
-            return (React.createElement(FieldMetadata, { metadata: metadata },
-                React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }))));
-        });
-    }
-    return (props) => {
-        var _a;
-        const { editable = true } = props;
-        const metadata = (_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata;
-        if (!metadata || !editable) {
-            return React.createElement(FieldComponent, Object.assign({}, props));
-        }
-        return (React.createElement(FieldMetadata, { metadata: metadata },
-            React.createElement(FieldComponent, Object.assign({}, props))));
-    };
-}
+import React, { forwardRef } from 'react';
+import { FieldMetadata } from '../components/FieldMetadata';
+/**
+ * Wraps the field component with metadata markup intended to be used for chromes hydration in Pages
+ * @param {ComponentType<FieldComponentProps>} FieldComponent the field component
+ * @param {boolean} isForwardRef set to 'true' if forward reference is needed
+ * @public
+ */
+export function withFieldMetadata(FieldComponent, isForwardRef = false) {
+    if (isForwardRef) {
+        return forwardRef((props, ref) => {
+            var _a;
+            const { editable = true } = props;
+            const metadata = (_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata;
+            if (!metadata || !editable) {
+                return React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }));
+            }
+            return (React.createElement(FieldMetadata, { metadata: metadata },
+                React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }))));
+        });
+    }
+    return (props) => {
+        var _a;
+        const { editable = true } = props;
+        const metadata = (_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata;
+        if (!metadata || !editable) {
+            return React.createElement(FieldComponent, Object.assign({}, props));
+        }
+        return (React.createElement(FieldMetadata, { metadata: metadata },
+            React.createElement(FieldComponent, Object.assign({}, props))));
+    };
+}

package/dist/esm/enhancers/withLoadImportMap.js

@@ -0,0 +1,17 @@
+import React, { useContext } from 'react';
+import { ImportMapReactContext } from '../components/SitecoreProvider';
+/**
+ * Higher-order component that injects the loadImportMap function from context into component props.
+ * If the component already receives loadImportMap via props, the prop value takes precedence.
+ * @param {React.ComponentClass<T> | React.FC<T>} Component - The component to enhance.
+ * @returns {React.ComponentClass<T> | React.FC<T>} The enhanced component with loadImportMap injected.
+ */
+export function withLoadImportMap(Component) {
+    const WithLoadImportMap = (props) => {
+        const loadImportMapContext = useContext(ImportMapReactContext);
+        const loadClientImportMap = props.loadImportMap || loadImportMapContext;
+        return React.createElement(Component, Object.assign({}, props, { loadImportMap: loadClientImportMap }));
+    };
+    WithLoadImportMap.displayName = `withLoadImportMap(${Component.displayName || Component.name || 'Component'})`;
+    return WithLoadImportMap;
+}

package/dist/esm/enhancers/withPlaceholder.js

@@ -1,59 +1,58 @@
-import React from 'react';
-import { withComponentMap } from './withComponentMap';
-import { withSitecore } from './withSitecore';
-import { PlaceholderComponent, getPlaceholderRenderings, } from '../components/Placeholder';
-/**
- * HOC to provide client-side placeholder functionality to a component.
- * @param {WithPlaceholderSpec} placeholders
- * @param {WithPlaceholderOptions} [options]
- */
-export function withPlaceholder(placeholders, options) {
-    return (WrappedComponent) => {
-        class WithPlaceholder extends PlaceholderComponent {
-            constructor(props) {
-                super(props);
-            }
-            render() {
-                let childProps = Object.assign({}, this.props);
-                delete childProps.componentMap;
-                if (options && options.propsTransformer) {
-                    childProps = options.propsTransformer(childProps);
-                }
-                if (this.state.error) {
-                    if (childProps.errorComponent) {
-                        return React.createElement(childProps.errorComponent, { error: this.state.error });
-                    }
-                    return (React.createElement("div", { className: "sc-content-sdk-placeholder-error" },
-                        "A rendering error occurred: ",
-                        this.state.error.message,
-                        "."));
-                }
-                const renderingData = options && options.resolvePlaceholderDataFromProps
-                    ? options.resolvePlaceholderDataFromProps(childProps)
-                    : childProps.rendering;
-                const definitelyArrayPlacholders = !Array.isArray(placeholders)
-                    ? [placeholders]
-                    : placeholders;
-                definitelyArrayPlacholders.forEach((placeholder) => {
-                    let placeholderData;
-                    if (typeof placeholder !== 'string' && placeholder.placeholder && placeholder.prop) {
-                        placeholderData = getPlaceholderRenderings(renderingData, placeholder.placeholder, childProps.page.mode.isEditing);
-                        if (placeholderData) {
-                            childProps[placeholder.prop] =
-                                PlaceholderComponent.getRenderedComponents(this.props, placeholderData);
-                        }
-                    }
-                    else {
-                        placeholderData = getPlaceholderRenderings(renderingData, placeholder, childProps.page.mode.isEditing);
-                        if (placeholderData) {
-                            childProps[placeholder] =
-                                PlaceholderComponent.getRenderedComponents(this.props, placeholderData);
-                        }
-                    }
-                });
-                return React.createElement(WrappedComponent, Object.assign({}, childProps));
-            }
-        }
-        return withSitecore()(withComponentMap(WithPlaceholder));
-    };
-}
+import React from 'react';
+import { withComponentMap } from './withComponentMap';
+import { withSitecore } from './withSitecore';
+import { PlaceholderComponent, getPlaceholderRenderings, } from '../components/Placeholder';
+import { ErrorComponent } from '../components/ErrorBoundary';
+/**
+ * HOC to provide client-side placeholder functionality to a component.
+ * @param {WithPlaceholderSpec} placeholders
+ * @param {WithPlaceholderOptions} [options]
+ * @public
+ */
+export function withPlaceholder(placeholders, options) {
+    return (WrappedComponent) => {
+        class WithPlaceholder extends PlaceholderComponent {
+            constructor(props) {
+                super(props);
+            }
+            render() {
+                let childProps = Object.assign({}, this.props);
+                delete childProps.componentMap;
+                if (options && options.propsTransformer) {
+                    childProps = options.propsTransformer(childProps);
+                }
+                if (this.state.error) {
+                    if (childProps.errorComponent) {
+                        return React.createElement(childProps.errorComponent, { error: this.state.error });
+                    }
+                    return (React.createElement(ErrorComponent, { message: `A rendering error occurred: ${this.state.error.message}.` }));
+                }
+                const renderingData = options && options.resolvePlaceholderDataFromProps
+                    ? options.resolvePlaceholderDataFromProps(childProps)
+                    : childProps.rendering;
+                const definitelyArrayPlacholders = !Array.isArray(placeholders)
+                    ? [placeholders]
+                    : placeholders;
+                definitelyArrayPlacholders.forEach((placeholder) => {
+                    let placeholderData;
+                    if (typeof placeholder !== 'string' && placeholder.placeholder && placeholder.prop) {
+                        placeholderData = getPlaceholderRenderings(renderingData, placeholder.placeholder, childProps.page.mode.isEditing);
+                        if (placeholderData) {
+                            childProps[placeholder.prop] =
+                                PlaceholderComponent.getRenderedComponents(this.props, placeholderData);
+                        }
+                    }
+                    else {
+                        placeholderData = getPlaceholderRenderings(renderingData, placeholder, childProps.page.mode.isEditing);
+                        if (placeholderData) {
+                            childProps[placeholder] =
+                                PlaceholderComponent.getRenderedComponents(this.props, placeholderData);
+                        }
+                    }
+                });
+                return React.createElement(WrappedComponent, Object.assign({}, childProps));
+            }
+        }
+        return withSitecore()(withComponentMap(WithPlaceholder));
+    };
+}