@sitecore-content-sdk/react 1.2.0-canary.8 → 1.2.0

package/dist/esm/components/Placeholder/ClientComponentWrapper.js

@@ -0,0 +1,14 @@
+'use client';
+import { ComponentMapReactContext } from '../SitecoreProvider';
+import { useContext } from 'react';
+import React from 'react';
+import { useSitecore } from '../../enhancers/withSitecore';
+import { getComponentForRendering } from './placeholder-utils';
+export const ClientComponentWrapper = (props) => {
+    const { page } = useSitecore();
+    const componentMap = useContext(ComponentMapReactContext);
+    const componentPropsWithContext = Object.assign(Object.assign({}, props.componentProps), { rendering: props.rendering, componentMap,
+        page });
+    const { component: Component } = getComponentForRendering(props.rendering, props.placeholderName, componentMap);
+    return React.createElement(Component, Object.assign({}, componentPropsWithContext));
+};

package/dist/esm/components/Placeholder/Placeholder.js

@@ -0,0 +1,103 @@
+'use client';
+import React from 'react';
+import { withComponentMap } from '../../enhancers/withComponentMap';
+import { PagesEditor } from '@sitecore-content-sdk/core/editing';
+import { withSitecore } from '../../enhancers/withSitecore';
+import { getComponentForRendering, getPlaceholderRenderings, getRenderedComponentProps, renderEmptyPlaceholder, } from './placeholder-utils';
+import { PlaceholderMetadata } from './PlaceholderMetadata';
+import ErrorBoundary from '../ErrorBoundary';
+export class PlaceholderComponent extends React.Component {
+    constructor(props) {
+        super(props);
+        this.isEmpty = false;
+        this.state = {};
+    }
+    componentDidMount() {
+        if (this.isEmpty && PagesEditor.isActive()) {
+            PagesEditor.resetChromes();
+        }
+    }
+    componentDidCatch(error) {
+        this.setState({ error });
+    }
+    /**
+     * Renders the placeholder when it is empty. The required CSS styles are applied to the placeholder in edit mode.
+     * @param {React.ReactNode | React.ReactElement[]} node react node
+     * @returns react node
+     * @deprecated use renderEmptyPlaceholder from react/nextjs import instead
+     */
+    renderEmptyPlaceholder(node) {
+        return renderEmptyPlaceholder(node);
+    }
+    render() {
+        const childProps = Object.assign({}, this.props);
+        delete childProps.componentMap;
+        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 = childProps.rendering;
+        const placeholderRenderings = getPlaceholderRenderings(renderingData, this.props.name, this.props.page.mode.isEditing);
+        this.isEmpty = !placeholderRenderings.length;
+        const components = PlaceholderComponent.getRenderedComponents(this.props, placeholderRenderings);
+        if (this.isEmpty) {
+            const rendered = this.props.renderEmpty ? this.props.renderEmpty(components) : components;
+            return this.props.page.mode.isEditing ? renderEmptyPlaceholder(rendered) : rendered;
+        }
+        else if (this.props.render) {
+            return this.props.render(components, placeholderRenderings, childProps);
+        }
+        else if (this.props.renderEach) {
+            const renderEach = this.props.renderEach;
+            return components.map((component, index) => {
+                if (component && component.props && component.props.type === 'text/sitecore') {
+                    return component;
+                }
+                return renderEach(component, index);
+            });
+        }
+        else {
+            return components;
+        }
+    }
+}
+/**
+ * Renders the components for the placeholder based on the provided rendering data.
+ * @param {PlaceholderProps} props placeholder component props
+ * @param {ComponentRendering[]} placeholderRenderings renderings within placeholder
+ * @returns {React.ReactNode | React.ReactElement[]} rendered components
+ */
+PlaceholderComponent.getRenderedComponents = (props, placeholderRenderings) => {
+    const { name, missingComponentComponent, hiddenRenderingComponent } = props;
+    const transformedComponents = placeholderRenderings
+        .map((componentRendering, index) => {
+        const key = componentRendering.uid || `component-${index}`;
+        const renderedProps = getRenderedComponentProps(props, componentRendering, key);
+        const component = getComponentForRendering(componentRendering, name, props.componentMap, hiddenRenderingComponent, missingComponentComponent);
+        let rendered = React.createElement(component.component, props.modifyComponentProps ? props.modifyComponentProps(renderedProps) : renderedProps);
+        if (!component.isEmpty) {
+            const errorBoundaryKey = rendered.type + '-' + index;
+            const disableSuspense = props.disableSuspense || false;
+            rendered = (React.createElement(ErrorBoundary, { "data-testid": "error-boundary", key: errorBoundaryKey, errorComponent: props.errorComponent, componentLoadingMessage: props.componentLoadingMessage, isDynamic: component.dynamic, disableSuspense: disableSuspense, rendering: rendered.props.rendering }, rendered));
+        }
+        // if in edit mode then emit shallow chromes for hydration in Pages
+        if (props.page.mode.isEditing) {
+            return (React.createElement(PlaceholderMetadata, { key: key, rendering: componentRendering }, rendered));
+        }
+        return rendered;
+    })
+        .filter((element) => element); // remove nulls
+    if (props.page.mode.isEditing) {
+        return [
+            React.createElement(PlaceholderMetadata, { key: props.rendering.uid, placeholderName: name, rendering: props.rendering }, transformedComponents),
+        ];
+    }
+    return transformedComponents;
+};
+const PlaceholderWithComponentMap = withComponentMap(PlaceholderComponent);
+export const Placeholder = withSitecore()(PlaceholderWithComponentMap);

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

@@ -0,0 +1,4 @@
+export { Placeholder, PlaceholderComponent } from './Placeholder';
+export { PlaceholderMetadata } from './PlaceholderMetadata';
+export { AppPlaceholder } from './AppPlaceholder';
+export * from './placeholder-utils';

package/dist/esm/components/Placeholder/models.js

@@ -0,0 +1,15 @@
+/**
+ * Prop names from placeholder that cannot be serialized and passed from server to client side components
+ */
+export const nonSerializedPlaceholderProps = [
+    'renderEmpty',
+    'render',
+    'renderEach',
+    'errorComponent',
+    'componentLoadingMessage',
+    'modifyComponentProps',
+    'componentMap',
+    'page',
+    'missingComponentComponent',
+    'hiddenRenderingComponent',
+];

package/dist/esm/components/Placeholder/placeholder-utils.js

@@ -0,0 +1,203 @@
+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 { MissingComponent } from '../MissingComponent';
+import { DEFAULT_EXPORT_NAME } from '../sharedTypes';
+import { isDynamicPlaceholder, getDynamicPlaceholderPattern, } from '@sitecore-content-sdk/core/layout';
+import { constants } from '@sitecore-content-sdk/core';
+import { HiddenRendering } from '../HiddenRendering';
+import { FEaaSComponent, FEaaSWrapper, BYOCComponent, BYOCWrapper, BYOC_COMPONENT_RENDERING_NAME, BYOC_WRAPPER_RENDERING_NAME, FEAAS_COMPONENT_RENDERING_NAME, FEAAS_WRAPPER_RENDERING_NAME, } from '../FEaaS';
+/**
+ * Get the renderings for the specified placeholder from the rendering data.
+ * @param {ComponentRendering | RouteData } rendering rendering data
+ * @param {string} name placeholder name
+ * @param {boolean} isEditing whether components should be rendered in editing mode
+ * @returns {ComponentRendering[]} array of component renderings
+ */
+export const getPlaceholderRenderings = (rendering, name, isEditing) => {
+    let result;
+    let phName = name.slice();
+    /**
+     * Process (SXA) dynamic placeholders
+     * Find and replace the matching dynamic placeholder e.g 'nameOfContainer-{*}' with the requested e.g. 'nameOfContainer-1'.
+     * For Metadata EditMode, we need to keep the raw placeholder name in place.
+     */
+    if (rendering === null || rendering === void 0 ? void 0 : rendering.placeholders) {
+        Object.keys(rendering.placeholders).forEach((placeholder) => {
+            const patternPlaceholder = isDynamicPlaceholder(placeholder)
+                ? getDynamicPlaceholderPattern(placeholder)
+                : null;
+            if (patternPlaceholder && patternPlaceholder.test(phName)) {
+                if (isEditing) {
+                    phName = placeholder;
+                }
+                else {
+                    rendering.placeholders[phName] = rendering.placeholders[placeholder];
+                    delete rendering.placeholders[placeholder];
+                }
+            }
+        });
+    }
+    if (rendering && rendering.placeholders && Object.keys(rendering.placeholders).length > 0) {
+        result = rendering.placeholders[phName];
+    }
+    else {
+        result = null;
+    }
+    if (!result) {
+        console.warn(`Placeholder '${phName}' was not found in the current rendering data`, JSON.stringify(rendering, null, 2));
+        return [];
+    }
+    return result;
+};
+/**
+ * Get SXA specific params from Sitecore rendering params
+ * @param {ComponentRendering} rendering rendering object
+ * @returns {object} converted SXA params
+ */
+export const getSXAParams = (rendering) => {
+    if (!rendering.params)
+        return {};
+    const { GridParameters, Styles } = rendering.params;
+    return ((GridParameters || Styles) && {
+        styles: `${GridParameters || ''} ${Styles || ''}`,
+    });
+};
+/**
+ * Renders the placeholder when it is empty. The required CSS styles are applied to the placeholder in edit mode.
+ * @param {React.ReactNode | React.ReactElement[]} node react node
+ * @returns react node
+ */
+export const renderEmptyPlaceholder = (node) => {
+    return React.createElement("div", { className: "sc-jss-empty-placeholder" }, node);
+};
+/**
+ * Get component props to be passed to the rendered component.
+ * @param {PlaceholderProps} placeholderProps current placeholder props
+ * @param {ComponentRendering} componentRendering rendering to be rendered
+ * @param {string} renderingKey unique key to pass over to rendering props
+ * @returns {RenderedProps} props to be passed to the rendered component
+ */
+export const getRenderedComponentProps = (placeholderProps, componentRendering, renderingKey) => {
+    // eslint-disable-next-line no-unused-vars
+    const { fields, params: placeholderParams } = placeholderProps, passThroughProps = __rest(placeholderProps, ["fields", "params"]);
+    delete passThroughProps.missingComponentComponent;
+    delete passThroughProps.hiddenRenderingComponent;
+    delete passThroughProps.name;
+    const mergedContentProps = getAppComponentProps(placeholderProps, componentRendering);
+    return Object.assign(Object.assign(Object.assign({ key: renderingKey }, passThroughProps), mergedContentProps), { rendering: componentRendering });
+};
+/**
+ * Merge placeholder and component field and params content props.
+ * @param {BasePlaceholderProps} placeholderProps placeholder props
+ * @param {ComponentRendering} componentRendering component rendering
+ * @returns {ComponentProps} merged props
+ */
+export function getAppComponentProps(placeholderProps, componentRendering) {
+    const fields = Object.assign(Object.assign({}, (placeholderProps.fields || {})), (componentRendering.fields || {}));
+    const params = Object.assign(Object.assign({}, (placeholderProps.params || {})), (componentRendering.params || {}));
+    return {
+        fields,
+        params: Object.assign(Object.assign({}, params), getSXAParams(componentRendering)),
+        rendering: componentRendering,
+    };
+}
+/**
+ * Get component implemenation from the component map based on the rendering definition.
+ * @param {ComponentRendering} renderingDefinition rendering data
+ * @param {string} placeholderName name of current placeholder
+ * @param {ComponentMap} componentMap component map for the current app
+ * @param {React.ComponentClass} [hiddenRenderingComponent] fallback implementation in to be rendered if the rendering is hidden
+ * @param {React.ComponentClass} [missingComponentComponent] fallback implementation in case no component is found in the component map
+ * @returns {ContentSDKComponet | null} component implementation or null if no component map is provided
+ */
+export const getComponentForRendering = (renderingDefinition, placeholderName, componentMap, hiddenRenderingComponent, missingComponentComponent) => {
+    var _a, _b;
+    if (renderingDefinition.componentName === constants.HIDDEN_RENDERING_NAME) {
+        return {
+            component: hiddenRenderingComponent !== null && hiddenRenderingComponent !== void 0 ? hiddenRenderingComponent : HiddenRendering,
+            isEmpty: true,
+            componentType: 'universal',
+        };
+    }
+    else if (!renderingDefinition.componentName) {
+        console.error(`Placeholder ${placeholderName} contains unknown component ${renderingDefinition.componentName}. Ensure that a React component exists for it, and that it is registered in your component-map file.`);
+        return {
+            component: () => React.createElement(React.Fragment, null),
+            isEmpty: true,
+            componentType: 'universal',
+        };
+    }
+    let component = null;
+    if (!componentMap || componentMap.size === 0) {
+        console.warn(`No components were available in component map to service request for component ${renderingDefinition}`);
+    }
+    else {
+        component = componentMap.get(renderingDefinition.componentName);
+    }
+    if (!component) {
+        // Fallback/defaults for Sitecore Component renderings (in case not defined in component map)
+        if (renderingDefinition.componentName === FEAAS_COMPONENT_RENDERING_NAME) {
+            return {
+                component: FEaaSComponent,
+                isEmpty: false,
+                componentType: 'universal',
+            };
+        }
+        else if (renderingDefinition.componentName === FEAAS_WRAPPER_RENDERING_NAME) {
+            return {
+                component: FEaaSWrapper,
+                isEmpty: false,
+                componentType: 'universal',
+            };
+        }
+        else if (renderingDefinition.componentName === BYOC_COMPONENT_RENDERING_NAME) {
+            return {
+                component: BYOCComponent,
+                isEmpty: false,
+                componentType: 'universal',
+            };
+        }
+        else if (renderingDefinition.componentName === BYOC_WRAPPER_RENDERING_NAME) {
+            // wrapping with error boundary could cause problems in case where parent component uses withPlaceholder HOC and tries to access its children props
+            // that's why we need to mark BYOC wrapper dynamic
+            return {
+                component: BYOCWrapper,
+                dynamic: true,
+                componentType: 'universal',
+                isEmpty: false,
+            };
+        }
+        return {
+            component: missingComponentComponent !== null && missingComponentComponent !== void 0 ? missingComponentComponent : MissingComponent,
+            isEmpty: true,
+            componentType: 'universal',
+        };
+    }
+    // Render SXA Rendering Variant if available
+    const exportName = (_a = renderingDefinition.params) === null || _a === void 0 ? void 0 : _a.FieldNames;
+    const renderedComponent = exportName && exportName !== DEFAULT_EXPORT_NAME
+        ? component[exportName]
+        : component.default ||
+            component.Default ||
+            component;
+    const dynamic = !!((_b = renderedComponent.render) === null || _b === void 0 ? void 0 : _b.preload) ||
+        renderingDefinition.componentName === BYOC_WRAPPER_RENDERING_NAME;
+    // all dynamic elements will have a separate render prop
+    return {
+        component: renderedComponent,
+        dynamic,
+        componentType: component
+            .componentType,
+        isEmpty: false,
+    };
+};

package/dist/esm/components/RichText.js

@@ -1,3 +1,4 @@
+'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)

package/dist/esm/components/Text.js

@@ -1,3 +1,4 @@
+'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)

package/dist/esm/enhancers/withAppPlaceholder.js

@@ -0,0 +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 }));
+    };
+};

package/dist/esm/enhancers/withEmptyFieldEditingComponent.js

@@ -10,18 +10,25 @@ export function withEmptyFieldEditingComponent(FieldComponent, options) {
         var _a;
         const { editable = true } = props;
         if (((_a = props.field) === null || _a === void 0 ? void 0 : _a.metadata) && editable && isFieldValueEmpty(props.field)) {
-            return props.emptyFieldEditingComponent || options.defaultEmptyFieldEditingComponent;
+            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 (React.createElement(React.Fragment, null, (EmptyFieldEditingComponent && React.createElement(EmptyFieldEditingComponent, null)) || (React.createElement(FieldComponent, Object.assign({}, props, { ref: ref })))));
+            const emptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
+            return (emptyFieldEditingComponent || (React.createElement(FieldComponent, Object.assign({}, props, { ref: ref }))));
         });
     }
     return (props) => {
-        const EmptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
-        return (React.createElement(React.Fragment, null, (EmptyFieldEditingComponent && React.createElement(EmptyFieldEditingComponent, null)) || (React.createElement(FieldComponent, Object.assign({}, props)))));
+        const emptyFieldEditingComponent = getEmptyFieldEditingComponent(props);
+        return emptyFieldEditingComponent || React.createElement(FieldComponent, Object.assign({}, props));
     };
 }

package/dist/esm/enhancers/withPlaceholder.js

@@ -1,14 +1,15 @@
 import React from 'react';
-import { PlaceholderCommon } from '../components/PlaceholderCommon';
 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 PlaceholderCommon {
+        class WithPlaceholder extends PlaceholderComponent {
             constructor(props) {
                 super(props);
             }
@@ -36,16 +37,17 @@ export function withPlaceholder(placeholders, options) {
                 definitelyArrayPlacholders.forEach((placeholder) => {
                     let placeholderData;
                     if (typeof placeholder !== 'string' && placeholder.placeholder && placeholder.prop) {
-                        placeholderData = PlaceholderCommon.getPlaceholderDataFromRenderingData(renderingData, placeholder.placeholder, childProps.page.mode.isEditing);
+                        placeholderData = getPlaceholderRenderings(renderingData, placeholder.placeholder, childProps.page.mode.isEditing);
                         if (placeholderData) {
-                            childProps[placeholder.prop] = this.getComponentsForRenderingData(placeholderData);
+                            childProps[placeholder.prop] =
+                                PlaceholderComponent.getRenderedComponents(this.props, placeholderData);
                         }
                     }
                     else {
-                        placeholderData = PlaceholderCommon.getPlaceholderDataFromRenderingData(renderingData, placeholder, childProps.page.mode.isEditing);
+                        placeholderData = getPlaceholderRenderings(renderingData, placeholder, childProps.page.mode.isEditing);
                         if (placeholderData) {
                             childProps[placeholder] =
-                                this.getComponentsForRenderingData(placeholderData);
+                                PlaceholderComponent.getRenderedComponents(this.props, placeholderData);
                         }
                     }
                 });

package/dist/esm/index.js

@@ -5,16 +5,15 @@ export { DictionaryService } from '@sitecore-content-sdk/core/i18n';
 export { DefaultRetryStrategy, GraphQLRequestClient, ErrorPage, } from '@sitecore-content-sdk/core/client';
 export { mediaApi } from '@sitecore-content-sdk/core/media';
 export { Form } from './components/Form';
-export { Placeholder } from './components/Placeholder';
+export { Placeholder, AppPlaceholder, } from './components/Placeholder';
 export { Image, } from './components/Image';
 export { RichText } from './components/RichText';
 export { Text } from './components/Text';
 export { DateField } from './components/Date';
-export { FEaaSComponent, fetchFEaaSComponentServerProps, } from './components/FEaaSComponent';
-export { FEaaSWrapper } from './components/FEaaSWrapper';
+export { FEaaSComponent, fetchFEaaSComponentServerProps, BYOCComponent, fetchBYOCComponentServerProps, 
+// leaving original names for backward compatibility
+BYOCWrapper, BYOCWrapper as BYOCClientWrapper, FEaaSWrapper, FEaaSWrapper as FEaaSClientWrapper, FEaaSServerWrapper, BYOCServerWrapper, } from './components/FEaaS';
 export { DesignLibrary } from './components/DesignLibrary';
-export { BYOCComponent, fetchBYOCComponentServerProps, } from './components/BYOCComponent';
-export { BYOCWrapper } from './components/BYOCWrapper';
 export { Link } from './components/Link';
 export { File } from './components/File';
 export { SitecoreProvider, SitecoreProviderReactContext, } from './components/SitecoreProvider';
@@ -26,4 +25,5 @@ export { withFieldMetadata } from './enhancers/withFieldMetadata';
 export { withEmptyFieldEditingComponent } from './enhancers/withEmptyFieldEditingComponent';
 export { EditingScripts } from './components/EditingScripts';
 export { DefaultEmptyFieldEditingComponentText, DefaultEmptyFieldEditingComponentImage, } from './components/DefaultEmptyFieldEditingComponents';
+export { ClientEditingChromesUpdate } from './components/ClientEditingChromesUpdate';
 export { SitePathService } from '@sitecore-content-sdk/core/site';

package/dist/esm/rsc-utils/no-rsc.js

@@ -0,0 +1,2 @@
+// Always false constant to import in the non-RSC contexts using conditional imports
+export const rsc = false;

package/dist/esm/rsc-utils/rsc.js

@@ -0,0 +1,2 @@
+// Always true constant to import in the RSC environment using conditional imports
+export const rsc = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sitecore-content-sdk/react",
-  "version": "1.2.0-canary.8",
+  "version": "1.2.0",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
@@ -38,6 +38,7 @@
     "@types/chai-string": "^1.4.5",
     "@types/mocha": "^10.0.10",
     "@types/node": "22.15.14",
+    "@types/proxyquire": "^1.3.31",
     "@types/react": "^19.1.3",
     "@types/react-dom": "^19.1.3",
     "@types/sinon": "^17.0.4",
@@ -58,6 +59,7 @@
     "mocha": "^11.2.2",
     "nyc": "^17.1.0",
     "prettier": "^2.8.0",
+    "proxyquire": "^2.1.3",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "sinon": "^20.0.0",
@@ -72,14 +74,24 @@
     "react-dom": "^19.1.0"
   },
   "dependencies": {
-    "@sitecore-content-sdk/core": "1.2.0-canary.8",
+    "@sitecore-content-sdk/core": "1.2.0",
     "fast-deep-equal": "^3.1.3"
   },
   "description": "",
   "types": "types/index.d.ts",
-  "gitHead": "6c28d70735881667365f3e65a423a90314fe5256",
+  "gitHead": "7c079f6f1d968ad39ce5b927559734c96d6adc20",
   "files": [
     "dist",
     "types"
-  ]
+  ],
+  "imports": {
+    "#rsc-env": {
+      "react-server": {
+        "import": "./dist/esm/rsc-utils/rsc.js",
+        "default": "./dist/cjs/rsc-utils/rsc.js"
+      },
+      "import": "./dist/esm/rsc-utils/no-rsc.js",
+      "default": "./dist/cjs/rsc-utils/no-rsc.js"
+    }
+  }
 }

package/types/components/ClientEditingChromesUpdate.d.ts

@@ -0,0 +1,6 @@
+import { JSX } from 'react';
+/**
+ * Updates editing chromes in app router / RSC context.
+ * This ensures all the relevant Pages editing markup is applied once all client components are loaded.
+ */
+export declare const ClientEditingChromesUpdate: () => JSX.Element;

package/types/components/Date.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { EditableFieldProps } from './sharedTypes';
 import { FieldMetadata } from '@sitecore-content-sdk/core/layout';
-export interface DateFieldProps extends EditableFieldProps {
+export interface DateFieldProps extends EditableFieldProps<DateFieldProps> {
     /** The date field data. */
     [htmlAttributes: string]: unknown;
     field: FieldMetadata & {

package/types/components/DefaultEmptyFieldEditingComponents.d.ts

@@ -1,3 +1,9 @@
 import React from 'react';
-export declare const DefaultEmptyFieldEditingComponentText: React.FC;
-export declare const DefaultEmptyFieldEditingComponentImage: React.FC;
+export declare const DefaultEmptyFieldEditingComponentText: React.FC<{
+    [key: string]: unknown;
+    tag?: string;
+}>;
+export declare const DefaultEmptyFieldEditingComponentImage: React.FC<{
+    [key: string]: unknown;
+    className?: string;
+}>;

package/types/components/DesignLibrary.d.ts

@@ -1,20 +1,9 @@
-import { JSX } from 'react';
+import React from 'react';
 import * as codegen from '@sitecore-content-sdk/core/codegen';
 export declare const __mockDependencies: (mocks: any) => void;
 export type ImportMapImport = {
     default: codegen.ImportEntry[];
 };
-type VariantGenerationProps = {
-    /**
-     * The import map to be used in variant generation mode.
-     */
-    loadImportMap?: () => Promise<ImportMapImport>;
-};
-/**
- * This component is used to render the component in variant generation mode.
- * It is used to send the import-map and component-props events to the parent window and render the dynamic component.
- */
-export declare const VariantGeneration: (props: VariantGenerationProps) => JSX.Element;
 type DesignLibraryProps = {
     /**
      * The dynamic import for import map to be used in variant generation mode.
@@ -22,5 +11,16 @@ type DesignLibraryProps = {
      */
     loadImportMap?: () => Promise<ImportMapImport>;
 };
-export declare const DesignLibrary: ({ loadImportMap }: DesignLibraryProps) => JSX.Element;
+/**
+ * Design Library component.
+ *
+ * Renders the **real** Sitecore component for `library` / `library-metadata` modes and,
+ * when generation is enabled (`page.mode.designLibrary.isVariantGeneration === true`),
+ * wires the **variant generation** handshake so the parent (DL Studio) can send
+ * generated code to preview and iterate on.
+ * @param {DesignLibraryProps} props
+ * @param {() => Promise<{ default: import('../codegen').ImportEntry[] }>} [props.loadImportMap] Optional async loader that resolves to the import-map used to resolve the generated component’s imports. Required when `isVariantGeneration` is true.
+ * @returns {JSX.Element} The preview surface, or `null` when not in Design Library mode.
+ */
+export declare const DesignLibrary: ({ loadImportMap }: DesignLibraryProps) => React.JSX.Element;
 export {};

package/types/components/ErrorBoundary.d.ts

@@ -7,7 +7,6 @@ type ErrorComponentProps = {
 export type ErrorBoundaryProps = {
     children: ReactNode;
     page: Page;
-    type: string;
     isDynamic?: boolean;
     errorComponent?: React.ComponentClass<ErrorComponentProps> | React.FC<ErrorComponentProps>;
     rendering?: ComponentRendering;

package/types/components/FEaaS/BYOCServerWrapper.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { BYOCServerWrapperProps } from './models';
+export declare const BYOCServerWrapper: (props: BYOCServerWrapperProps) => Promise<React.JSX.Element>;

package/types/components/FEaaS/BYOCWrapper.d.ts

@@ -0,0 +1,25 @@
+import React, { JSX } from 'react';
+import { BYOCComponentProps } from './models';
+/**
+ * BYOCComponent facilitate the rendering of external components. It manages potential errors,
+ * missing components, and customization of error messages or alternative rendering components.
+ * @param {ByocComponentProps} props component props
+ * @returns dynamically rendered component or Missing Component error frame
+ */
+export declare class BYOCComponent extends React.Component<BYOCComponentProps> {
+    state: Readonly<{
+        error?: Error;
+    }>;
+    constructor(props: BYOCComponentProps);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error): void;
+    render(): JSX.Element;
+}
+/**
+ * SXA wrapper for BYOC components
+ * @param {BYOCComponentProps} props component props
+ * @returns wrapped BYOC component
+ */
+export declare const BYOCWrapper: (props: BYOCComponentProps) => JSX.Element;

package/types/components/FEaaS/FEaaSSeverWrapper.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { FEaaSServerWrapperProps } from './models';
+/**
+ * Server component for FEaaS. Retrieves server props and renders client FEaaSWrapper.
+ * @param {FEaaSComponentProps} props incoming props
+ * @returns {Promise<JSX.Element>} rendered FEaaSWrapper component
+ */
+export declare const FEaaSServerWrapper: (props: FEaaSServerWrapperProps) => Promise<React.JSX.Element>;