@sitecore-content-sdk/content 1.5.0-canary.5

package/dist/esm/config/define-config.js

@@ -0,0 +1,189 @@
+import { constants, DefaultRetryStrategy } from '@sitecore-content-sdk/core';
+import { SITECORE_CLI_MODE_ENV_VAR } from '../config-cli';
+const { SITECORE_EDGE_URL_DEFAULT } = constants;
+/**
+ * Provides default initial values for SitecoreConfig
+ * @returns default config
+ */
+export const getFallbackConfig = () => ({
+    api: {
+        edge: {
+            contextId: process.env.SITECORE_EDGE_CONTEXT_ID || '',
+            clientContextId: '',
+            edgeUrl: process.env.SITECORE_EDGE_URL || SITECORE_EDGE_URL_DEFAULT,
+        },
+        local: {
+            apiKey: process.env.SITECORE_API_KEY || process.env.NEXT_PUBLIC_SITECORE_API_KEY || '',
+            apiHost: process.env.SITECORE_API_HOST || process.env.NEXT_PUBLIC_SITECORE_API_HOST || '',
+            path: '/sitecore/api/graph/edge',
+        },
+    },
+    editingSecret: process.env.SITECORE_EDITING_SECRET || 'editing-secret-missing',
+    retries: {
+        count: 3,
+        retryStrategy: new DefaultRetryStrategy({
+            statusCodes: [429, 502, 503, 504, 520, 521, 522, 523, 524],
+        }),
+    },
+    redirects: {
+        enabled: process.env.NODE_ENV !== 'development',
+        locales: ['en'],
+    },
+    multisite: {
+        enabled: true,
+        useCookieResolution: () => false,
+    },
+    personalize: {
+        enabled: process.env.NODE_ENV !== 'development',
+        edgeTimeout: parseInt(process.env.PERSONALIZE_MIDDLEWARE_EDGE_TIMEOUT, 10) || 400,
+        cdpTimeout: parseInt(process.env.PERSONALIZE_MIDDLEWARE_CDP_TIMEOUT, 10) || 400,
+        scope: '',
+        channel: 'WEB',
+        currency: 'USD',
+    },
+    defaultSite: '',
+    defaultLanguage: 'en',
+    layout: {
+        formatLayoutQuery: null,
+    },
+    dictionary: {
+        caching: {
+            enabled: true,
+            timeout: 60,
+        },
+    },
+    disableCodeGeneration: false,
+});
+/**
+ * Deep merge utility that skips undefined or empty string values in the override.
+ * @param {T} base base value
+ * @param {DeepPartial<T>} [override] override value
+ */
+export function deepMerge(base, override) {
+    if (!override)
+        return base;
+    const result = Object.assign({}, base);
+    for (const key in override) {
+        if (!Object.prototype.hasOwnProperty.call(override, key))
+            continue;
+        const typedKey = key;
+        const baseValue = base[typedKey];
+        const overrideValue = override[typedKey];
+        // Skip undefined and empty string overrides
+        if (overrideValue === undefined || overrideValue === '') {
+            continue;
+        }
+        if (typeof overrideValue === 'object' &&
+            overrideValue !== null &&
+            !Array.isArray(overrideValue) &&
+            Object.getPrototypeOf(overrideValue) === Object.prototype) {
+            result[typedKey] = deepMerge(baseValue, overrideValue);
+        }
+        else {
+            result[typedKey] = overrideValue;
+        }
+    }
+    return result;
+}
+/**
+ * Resolves sitecore config based on base config and overrides
+ * @param {SitecoreConfig} base base sitecore config object
+ * @param {SitecoreConfig} override override sitecore config object
+ * @returns resolved SitecoreConfig object
+ */
+const resolveConfig = (base, override) => {
+    const result = deepMerge(base, override);
+    if (Number.isNaN(result.personalize.cdpTimeout) || !result.personalize.cdpTimeout) {
+        result.personalize.cdpTimeout = base.personalize.cdpTimeout;
+    }
+    if (Number.isNaN(result.personalize.edgeTimeout) || !result.personalize.edgeTimeout) {
+        result.personalize.edgeTimeout = base.personalize.edgeTimeout;
+    }
+    return result;
+};
+const validateApiConfiguration = (config) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const isBrowser = typeof window !== 'undefined';
+    const hasEdgeContextId = !!((_b = (_a = config.api) === null || _a === void 0 ? void 0 : _a.edge) === null || _b === void 0 ? void 0 : _b.contextId);
+    const hasClientContextId = !!((_d = (_c = config.api) === null || _c === void 0 ? void 0 : _c.edge) === null || _d === void 0 ? void 0 : _d.clientContextId);
+    const hasLocalCreds = !!((_f = (_e = config.api) === null || _e === void 0 ? void 0 : _e.local) === null || _f === void 0 ? void 0 : _f.apiHost) && !!((_h = (_g = config.api) === null || _g === void 0 ? void 0 : _g.local) === null || _h === void 0 ? void 0 : _h.apiKey);
+    // Server-side: allow Edge OR Local; clientContextId alone is NOT sufficient
+    if (!isBrowser) {
+        if (!hasEdgeContextId && !hasLocalCreds) {
+            throw new Error('Configuration error: provide either Edge contextId (api.edge.contextId) or local credentials (api.local.apiHost + api.local.apiKey).');
+        }
+        if (hasEdgeContextId && !hasClientContextId) {
+            // eslint-disable-next-line no-console
+            if (process.env.NODE_ENV === 'development') {
+                console.warn('Warning: only a server-side edge contextId is provided. Client-side requests will require api.edge.clientContextId or a proxy.');
+            }
+        }
+        return; // validation complete on the server
+    }
+    // Browser-side warning (runs only if contextId exists but clientContextId is missing)
+    if (isBrowser && !hasClientContextId) {
+        // eslint-disable-next-line no-console
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`Warning: clientContextId is missing. The browser will use contextId instead.
+  Client Side functionalities (like Tracking and Personalization) may be limited.`);
+        }
+    }
+};
+/**
+ * The validators for the config object during build time.
+ * Validators are called when the literal path of the config object is accessed.
+ */
+const PROPERTY_VALIDATORS = {
+    'api.edge.contextId': validateApiConfiguration,
+    'api.local.apiKey': validateApiConfiguration,
+};
+/**
+ * Creates a proxy for the config object to validate the config object during build time.
+ * @param {SitecoreConfig} config - The config object to create a proxy for.
+ * @returns {SitecoreConfig} The proxy for the config object.
+ */
+const createConfigProxy = (config) => {
+    const validated = new Set();
+    const createProxy = (target, propPath = '') => {
+        return new Proxy(target, {
+            get(obj, prop, receiver) {
+                // Skip symbol properties, do not attempt to stringify them
+                // Type safety check
+                if (typeof prop === 'symbol') {
+                    return Reflect.get(obj, prop, receiver);
+                }
+                const fullPath = propPath ? `${propPath}.${prop}` : prop;
+                const value = Reflect.get(obj, prop, receiver);
+                if (fullPath in PROPERTY_VALIDATORS &&
+                    !validated.has(fullPath)) {
+                    const validator = PROPERTY_VALIDATORS[fullPath];
+                    validator(config);
+                    validated.add(fullPath);
+                }
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    return createProxy(value, fullPath);
+                }
+                return value;
+            },
+        });
+    };
+    return createProxy(config);
+};
+/**
+ * Accepts a SitecoreConfigInput object and returns full sitecore configuration
+ * @param {SitecoreConfigInput} config override values to be written over default config settings
+ * @returns {SitecoreConfig} full sitecore configuration to use in application
+ * @public
+ */
+export const defineConfig = (config) => {
+    const resolvedConfig = resolveConfig(getFallbackConfig(), config);
+    const isCLI = process.env[SITECORE_CLI_MODE_ENV_VAR] === 'true';
+    // At `build time`, we create a proxy for the config object to validate the config by
+    // accessing the literal paths instead of validating the whole object at once.
+    // At `runtime` all the config should be validated to fail fast in case of invalid configuration.
+    if (isCLI) {
+        return createConfigProxy(resolvedConfig);
+    }
+    validateApiConfiguration(resolvedConfig);
+    return resolvedConfig;
+};

package/dist/esm/config/index.js

@@ -0,0 +1,2 @@
+export { ComponentTemplateType, } from './models';
+export { defineConfig } from './define-config';

package/dist/esm/config/models.js

@@ -0,0 +1,9 @@
+/**
+ * Enumeration of default component templates
+ * @internal
+ */
+export var ComponentTemplateType;
+(function (ComponentTemplateType) {
+    ComponentTemplateType["BYOC"] = "byoc";
+    ComponentTemplateType["DEFAULT"] = "default";
+})(ComponentTemplateType || (ComponentTemplateType = {}));

package/dist/esm/config-cli/define-cli-config.js

@@ -0,0 +1,19 @@
+const validateConfig = (cliConfig) => {
+    var _a, _b, _c, _d;
+    if (!((_b = (_a = cliConfig.build) === null || _a === void 0 ? void 0 : _a.commands) === null || _b === void 0 ? void 0 : _b.length)) {
+        throw new Error('Configuration error: build commands should be defined in sitecore.cli.config');
+    }
+    if (!((_d = (_c = cliConfig.scaffold) === null || _c === void 0 ? void 0 : _c.templates) === null || _d === void 0 ? void 0 : _d.length)) {
+        throw new Error('Configuration error: scaffold templates should be defined in sitecore.cli.config');
+    }
+};
+/**
+ * Accepts a `SitecoreCliConfigInput` object and returns Sitecore Content SDK CLI configuration, updated with required default values
+ * @param {SitecoreCliConfigInput} cliConfig the cli configuration provided by the application
+ * @returns {SitecoreCliConfig} full sitecore cli configuration to use with cli
+ * @public
+ */
+export const defineCliConfig = (cliConfig) => {
+    validateConfig(cliConfig);
+    return cliConfig;
+};

package/dist/esm/config-cli/index.js

@@ -0,0 +1,2 @@
+export { defineCliConfig } from './define-cli-config';
+export { SITECORE_CLI_MODE_ENV_VAR } from './models';

package/dist/esm/config-cli/models.js

@@ -0,0 +1,5 @@
+/**
+ * Environment variable to indicate that the application is running in CLI mode
+ * @internal
+ */
+export const SITECORE_CLI_MODE_ENV_VAR = 'SITECORE_CLI_MODE';

package/dist/esm/constants.js

@@ -0,0 +1,9 @@
+/** @private */
+export const siteNameError = 'The site name must be a non-empty string';
+/** @private */
+export const languageError = 'The language must be a non-empty string';
+/**
+ * Hidden rendering name
+ * @internal
+ */
+export const HIDDEN_RENDERING_NAME = 'Hidden Rendering';

package/dist/esm/debug.js

@@ -0,0 +1,19 @@
+import { debugNamespace, debugModule } from '@sitecore-content-sdk/core';
+/**
+ * Debug module for content package
+ * @public
+ */
+const debug = {
+    form: debugModule(`${debugNamespace}:form`),
+    layout: debugModule(`${debugNamespace}:layout`),
+    dictionary: debugModule(`${debugNamespace}:dictionary`),
+    editing: debugModule(`${debugNamespace}:editing`),
+    sitemap: debugModule(`${debugNamespace}:sitemap`),
+    multisite: debugModule(`${debugNamespace}:multisite`),
+    robots: debugModule(`${debugNamespace}:robots`),
+    redirects: debugModule(`${debugNamespace}:redirects`),
+    personalize: debugModule(`${debugNamespace}:personalize`),
+    locale: debugModule(`${debugNamespace}:locale`),
+    errorpages: debugModule(`${debugNamespace}:errorpages`),
+};
+export default debug;

package/dist/esm/editing/codegen/index.js

@@ -0,0 +1 @@
+export { addComponentPreviewHandler, addServerComponentPreviewHandler, getDesignLibraryComponentPreviewErrorEvent, getDesignLibraryComponentPropsEvent, getDesignLibraryImportMapEvent, getImportMapInfo, addStyleElement, createComponentInstance, sendErrorEvent, DesignLibraryPreviewError, } from './preview';

package/dist/esm/editing/codegen/preview.js

@@ -0,0 +1,263 @@
+import { validateEvent } from '../design-library';
+/**
+ * Event to send import map to design library
+ */
+const DESIGN_LIBRARY_IMPORT_MAP_EVENT_NAME = 'component:generation:import-map';
+/**
+ * Event to send component props to design library
+ */
+const DESIGN_LIBRARY_COMPONENT_PROPS_EVENT_NAME = 'component:generation:component-props';
+/**
+ * Event to receive component data from design library
+ */
+const DESIGN_LIBRARY_COMPONENT_PREVIEW_EVENT_NAME = 'component:generation:component-preview';
+/**
+ * Event to send component error to design library
+ */
+const DESIGN_LIBRARY_COMPONENT_PREVIEW_ERROR_EVENT_NAME = 'component:generation:component-preview-error';
+/**
+ * Enumeration of error types for the design library preview.
+ * @internal
+ */
+export var DesignLibraryPreviewError;
+(function (DesignLibraryPreviewError) {
+    /**
+     * Error occurred during component rendering.
+     */
+    DesignLibraryPreviewError["Render"] = "render";
+    /**
+     * Error occurred during component and event handlers initialization.
+     */
+    DesignLibraryPreviewError["RenderInit"] = "render-init";
+})(DesignLibraryPreviewError || (DesignLibraryPreviewError = {}));
+/**
+ * Builds the component dependencies from the component imports and the import map.
+ * @param {ComponentImport[]} componentImports - The component imports.
+ * @param {ImportEntry[]} importMap - The import map to be used for the component.
+ * @returns {Array<{ name: string; value: unknown }>} The component dependencies.
+ */
+export function buildComponentDependencies(componentImports, importMap) {
+    const successful = [];
+    const missing = {
+        modules: [],
+        exports: [],
+    };
+    componentImports.forEach((componentImport) => {
+        const moduleEntry = importMap.find((entry) => entry.module === componentImport.module);
+        if (!moduleEntry) {
+            missing.modules.push({
+                module: componentImport.module,
+                alias: componentImport.alias,
+            });
+            return;
+        }
+        const exportEntry = moduleEntry.exports.find((exp) => exp.name === componentImport.export);
+        if (!exportEntry) {
+            missing.exports.push({
+                alias: componentImport.alias,
+                export: componentImport.export,
+                module: componentImport.module,
+            });
+            return;
+        }
+        return successful.push({
+            name: componentImport.alias,
+            value: exportEntry.value,
+        });
+    });
+    return {
+        successful,
+        missing,
+    };
+}
+/**
+ * Adds the browser-side event handler for 'component:generation:component-preview' message used in Design Library
+ * The event should contain the component code, styles and imports.
+ * @param {ImportEntry[]} importMap - The import map to be used for the component.
+ * @param {Function} callback callback to be called after component is received
+ * @internal
+ */
+export const addComponentPreviewHandler = (importMap, callback) => {
+    if (!window)
+        return;
+    const handler = (e) => {
+        const eventArgs = e.data;
+        try {
+            if (!validateEvent(e, DESIGN_LIBRARY_COMPONENT_PREVIEW_EVENT_NAME)) {
+                return;
+            }
+            console.debug('Component Library: message received', eventArgs);
+            const Component = createComponentInstance(importMap, eventArgs);
+            addStyleElement(eventArgs.message.styles.content);
+            callback(null, Component);
+        }
+        catch (error) {
+            sendErrorEvent(eventArgs.message.uid, error, DesignLibraryPreviewError.RenderInit);
+            callback(error, null);
+        }
+    };
+    window.addEventListener('message', handler);
+    const unsubscribe = () => {
+        window.removeEventListener('message', handler);
+    };
+    return unsubscribe;
+};
+/**
+ * Adds the browser-side event handler for 'component:generation:component-preview' message used in Design Library for server components
+ * The event should contain the component code, styles and imports.
+ * @param {Function} callback callback to be called after component is received
+ * @internal
+ */
+export const addServerComponentPreviewHandler = (callback) => {
+    const handler = (e) => {
+        if (!validateEvent(e, DESIGN_LIBRARY_COMPONENT_PREVIEW_EVENT_NAME)) {
+            return;
+        }
+        console.debug('Component Library: message received', e.data);
+        callback(e.data);
+    };
+    window.addEventListener('message', handler);
+    const unsubscribe = () => {
+        window.removeEventListener('message', handler);
+    };
+    return unsubscribe;
+};
+/**
+ * Adds <style> element in the document head with the provided CSS.
+ * If an existing style element with the id "content-sdk-style-preview" is found, it is removed
+ * to prevent duplicates
+ * @param {string} stylesContent - The raw CSS text to inject into the style element.
+ * @internal
+ */
+export function addStyleElement(stylesContent) {
+    const styleId = 'content-sdk-style-preview';
+    const styleElement = document.getElementById(styleId);
+    // remove existing style element if it exists to avoid duplicates
+    if (styleElement) {
+        styleElement.remove();
+    }
+    // create new style element and attach it to DOM
+    const style = document.createElement('style');
+    style.setAttribute('id', styleId);
+    style.innerHTML = stylesContent;
+    document.head.appendChild(style);
+}
+/**
+ * Dynamically creates a React component instance from provided importMap and from code, styles, and dependencies provided in the preview event.
+ * @param {ImportEntry[]} importMap - The import map containing module and export references that might be injected as dependencies in the provided code.
+ * @param {ComponentPreviewEventArgs} previewEventArgs - The event arguments containing the component code, styles, and import definitions.
+ * @returns The dynamically created React component instance.
+ * @throws If any required modules or exports are missing from the import map, an error is thrown describing the missing dependencies.
+ * @internal
+ */
+export const createComponentInstance = (importMap, previewEventArgs) => {
+    const { message } = previewEventArgs;
+    const dependencies = buildComponentDependencies(message.imports, importMap);
+    if (dependencies.missing.modules.length > 0 || dependencies.missing.exports.length > 0) {
+        let errorMessage = '';
+        dependencies.missing.modules.forEach((mod) => {
+            errorMessage += `Missing module: '${mod.module}' with alias: '${mod.alias}'\n`;
+        });
+        dependencies.missing.exports.forEach((exp) => {
+            const alias = exp.export !== exp.alias ? ` with alias: '${exp.alias}'` : '';
+            errorMessage += `Missing export: '${exp.export}' from module: '${exp.module}'${alias}\n`;
+        });
+        throw errorMessage;
+    }
+    const importNames = dependencies.successful.map((entry) => entry.name);
+    const importInstances = dependencies.successful.map((entry) => entry.value);
+    const exports = { Component: null };
+    const componentFn = new Function('exports', message.styles.styleImport.name, ...importNames, message.code.content);
+    // Function will set exports.Component
+    componentFn(exports, message.styles.styleImport.content, ...importInstances);
+    return exports.Component;
+};
+/**
+ * Generates a DesignLibraryComponentPreviewErrorEvent with the given uid and error.
+ * @param {string} uid - The unique identifier for the event.
+ * @param {unknown} error - The error to be sent.
+ * @param {DesignLibraryPreviewError} type - The type of error.
+ * @returns An object representing the DesignLibraryComponentPreviewErrorEvent.
+ * @internal
+ */
+export function getDesignLibraryComponentPreviewErrorEvent(uid, error, type) {
+    return {
+        name: DESIGN_LIBRARY_COMPONENT_PREVIEW_ERROR_EVENT_NAME,
+        message: { uid, error, type },
+    };
+}
+/**
+ * Generates a DesignLibraryComponentPropsEvent with the given uid, fields and parameters.
+ * @param {string} uid - The unique identifier for the event.
+ * @param {ComponentFields} fields - The fields of the component.
+ * @param {ComponentParams} parameters - The parameters of the component.
+ * @returns An object representing the DesignLibraryComponentPropsEvent.
+ * @internal
+ */
+export function getDesignLibraryComponentPropsEvent(uid, fields = {}, parameters = {}) {
+    return {
+        name: DESIGN_LIBRARY_COMPONENT_PROPS_EVENT_NAME,
+        message: {
+            uid,
+            fields,
+            parameters,
+        },
+    };
+}
+/**
+ * Generates a DesignLibraryImportMapEvent with the given uid and importMap.
+ * @param {string} uid - The unique identifier for the event.
+ * @param {ImportEntry[]} importMap - The imports map to be sent.
+ * @returns An object representing the DesignLibraryImportMapEvent.
+ * @internal
+ */
+export function getDesignLibraryImportMapEvent(uid, importMap) {
+    const importMapPayload = isImportEntryInfoArray(importMap)
+        ? importMap
+        : getImportMapInfo(importMap);
+    return {
+        name: DESIGN_LIBRARY_IMPORT_MAP_EVENT_NAME,
+        message: {
+            uid,
+            importMap: importMapPayload,
+        },
+    };
+}
+/**
+ * Generates the payload for the import map to be sent to design library.
+ * @param {ImportEntry[]} importMap - The imports map to be sent.
+ * @internal
+ */
+export function getImportMapInfo(importMap) {
+    return importMap.map((entry) => ({
+        module: entry.module,
+        exports: entry.exports.map((exp) => exp.name),
+    }));
+}
+/**
+ * Type guard for ImportEntryInfo[]
+ * @param {unknown} data import entry data to check
+ * @returns true if the data is ImportEntryInfo array
+ */
+export function isImportEntryInfoArray(data) {
+    return (Array.isArray(data) &&
+        data.length > 0 &&
+        typeof data[0].module === 'string' &&
+        Array.isArray(data[0].exports) &&
+        typeof data[0].exports[0] === 'string');
+}
+/**
+ * Sends a component preview error event to the design library
+ * @param {string} uid - The unique identifier of the component that's being edited.
+ * @param {unknown} error - The error object or message to be sent.
+ * @param {DesignLibraryPreviewError} type - The type of error, as defined in DesignLibraryPreviewError.
+ * @internal
+ */
+export const sendErrorEvent = (uid, error, type) => {
+    const errorEvent = getDesignLibraryComponentPreviewErrorEvent(uid, error, type);
+    console.error('Component Library: sending error event', errorEvent);
+    if (typeof window !== 'undefined') {
+        const target = window.parent && window.parent !== window ? window.parent : window;
+        target.postMessage(errorEvent, '*');
+    }
+};

package/dist/esm/editing/component-layout-service.js

@@ -0,0 +1,55 @@
+import { NativeDataFetcher, constants } from '@sitecore-content-sdk/core';
+import { resolveUrl } from '@sitecore-content-sdk/core/tools';
+import debug from '../debug';
+import { DesignLibraryMode } from './models';
+const { SITECORE_EDGE_URL_DEFAULT } = constants;
+/**
+ * REST service that enables Design Library functionality.
+ * Returns layout data for a single rendered component.
+ * @public
+ */
+export class ComponentLayoutService {
+    constructor(config) {
+        this.config = config;
+    }
+    fetchComponentData(params, fetchOptions) {
+        // Choose the correct Edge ID per environment
+        const sitecoreContextId = this.config.contextId || this.config.clientContextId;
+        if (!sitecoreContextId) {
+            throw new Error(`ComponentLayoutService misconfigured: contextId is missing.
+         Provide contextId on the server, and clientContextId in the browser if you need to full client-side functionality.`);
+        }
+        const fetcher = new NativeDataFetcher({ debugger: debug.layout });
+        debug.layout('fetching component with uid %s for %s %s %s %s', params.componentUid, params.itemId, params.language, params.siteName, params.dataSourceId);
+        return fetcher
+            .get(this.getFetchUrl(params), Object.assign(Object.assign({}, fetchOptions), { headers: Object.assign(Object.assign({}, fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.headers), { 'x-sitecore-contextid': sitecoreContextId, sc_editMode: `${params.mode === DesignLibraryMode.Metadata}` }) }))
+            .then((response) => response.data)
+            .catch((error) => {
+            var _a;
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                return error.response.data;
+            }
+            throw error;
+        });
+    }
+    getComponentFetchParams(params) {
+        // strip undefined fields
+        return JSON.parse(JSON.stringify({
+            item: params.itemId,
+            uid: params.componentUid,
+            dataSourceId: params.dataSourceId,
+            renderingItemId: params.renderingId,
+            version: params.version,
+            sc_site: params.siteName,
+            sc_lang: params.language || 'en',
+        }));
+    }
+    /**
+     * Get the fetch URL for the partial layout data endpoint
+     * @param {ComponentLayoutRequestParams} params - The parameters for the request
+     * @returns {string} The fetch URL for the component data
+     */
+    getFetchUrl(params) {
+        return resolveUrl(`${this.config.edgeUrl || SITECORE_EDGE_URL_DEFAULT}/layout/component`, this.getComponentFetchParams(params));
+    }
+}