@enonic/nextjs-adapter 3.3.0-B1 → 3.3.0

package/dist/views/Text.jsx.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.jsx","sourceRoot":"","sources":["../../src/views/Text.tsx"],"names":[],"mappings":"AAIA,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAU1C,MAAM,eAAe,GAAG,CAAC,EAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAQ,EAAE,EAAE,CAAC,CACxD,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,qBAAqB,CAAC,CAAC,KAAK,CAAC,EAAE,CACnF,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/views/macros/DefaultMacro.d.ts

@@ -0,0 +1,3 @@
+import type { MacroProps } from '../../types';
+declare const DefaultMacro: ({ name, config, meta }: MacroProps) => JSX.Element;
+export default DefaultMacro;

package/dist/views/macros/DefaultMacro.jsx

@@ -0,0 +1,4 @@
+import HTMLReactParser from 'html-react-parser';
+const DefaultMacro = ({ name, config, meta }) => HTMLReactParser(config.body);
+export default DefaultMacro;
+//# sourceMappingURL=DefaultMacro.jsx.map

package/dist/views/macros/DefaultMacro.jsx.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultMacro.jsx","sourceRoot":"","sources":["../../../src/views/macros/DefaultMacro.tsx"],"names":[],"mappings":"AACA,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAGhD,MAAM,YAAY,GAAG,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAa,EAAE,EAAE,CACtD,eAAe,CAAC,MAAM,CAAC,IAAI,CAC9B,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/views/macros/DisableMacro.d.ts

@@ -0,0 +1,3 @@
+import type { MacroProps } from '../../types';
+declare const DisableMacro: ({ name, config, meta }: MacroProps) => any;
+export default DisableMacro;

package/dist/views/macros/DisableMacro.jsx

@@ -0,0 +1,3 @@
+const DisableMacro = ({ name, config, meta }) => (config.body);
+export default DisableMacro;
+//# sourceMappingURL=DisableMacro.jsx.map

package/dist/views/macros/DisableMacro.jsx.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisableMacro.jsx","sourceRoot":"","sources":["../../../src/views/macros/DisableMacro.tsx"],"names":[],"mappings":"AAGA,MAAM,YAAY,GAAG,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAa,EAAE,EAAE,CAAC,CACvD,MAAM,CAAC,IAAI,CACd,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/package.json

@@ -1,29 +1,17 @@
 {
   "name": "@enonic/nextjs-adapter",
-  "version": "3.3.0-B1",
+  "version": "3.3.0",
   "license": "Apache-2.0",
-  "main": "index.js",
+  "main": "dist/index.js",
   "author": "Pavel Milkevich <pmi@enonic.com>",
   "contributors": [
     "Christian Westgaard <cwe@enonic.com>"
   ],
   "files": [
-    "*.d.ts",
-    "*.map",
-    "baseMappings*",
-    "client.js",
-    "server.js",
-    "common",
-    "client",
-    "server",
-    "guillotine",
-    "index*",
-    "i18n",
-    "query",
-    "src",
-    "types",
-    "utils",
-    "views"
+    "dist",
+    "LICENSE",
+    "package.json",
+    "README.md"
   ],
   "exports": {
     ".": {
@@ -54,7 +42,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "clean": "del-cli dist/ *.tgz",
+    "clean": "del-cli dist/ enonic-nextjs-adapter-*.tgz",
     "check:types": "tsc --noEmit",
     "madge": "madge -i docs/madge.png -x '(constants|env)\\.ts' src/index.ts",
     "lint": "eslint --quiet --cache src",
@@ -67,31 +55,31 @@
     "test": "jest --no-cache --coverage"
   },
   "dependencies": {
-    "@enonic/react-components": "^6.0.0-RC5",
+    "@enonic/react-components": "^6.0.0",
     "@formatjs/intl-localematcher": "^0.6.1",
-    "gqlmin": "^0.2.2",
+    "gqlmin": "^0.3.1",
     "negotiator": "^1.0.0",
     "unescape": "^1.0.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
+    "@babel/core": "^7.28.3",
+    "@babel/preset-env": "^7.28.3",
     "@edge-runtime/jest-environment": "^4.0.0",
     "@enonic-types/core": "^7.15.3",
-    "@enonic/eslint-config": "^2.0.1",
-    "@testing-library/jest-dom": "^6.6.4",
+    "@enonic/eslint-config": "^2.1.0",
+    "@testing-library/jest-dom": "^6.8.0",
     "@testing-library/react": "^16.3.0",
     "@types/negotiator": "^0.6.4",
-    "@types/node": "^24.2.1",
+    "@types/node": "^24.3.0",
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
-    "@typescript-eslint/eslint-plugin": "^8.38.0",
-    "@typescript-eslint/parser": "^8.39.0",
+    "@typescript-eslint/eslint-plugin": "^8.40.0",
+    "@typescript-eslint/parser": "^8.40.0",
     "babel-jest": "^30.0.5",
     "concurrently": "^9.2.0",
-    "cpy-cli": "^5.0.0",
+    "cpy-cli": "^6.0.0",
     "del-cli": "^6.0.0",
-    "eslint": "^9.32.0",
+    "eslint": "^9.34.0",
     "eslint-plugin-react": "^7.37.5",
     "jest": "^30.0.5",
     "jest-environment-jsdom": "^30.0.5",
@@ -99,12 +87,12 @@
     "mkdirp": "^3.0.1",
     "ts-jest": "^29.4.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "types": "index.d.ts",
   "peerDependencies": {
     "html-react-parser": "^5.2.6",
-    "next": "^15.4.5",
+    "next": "^14.2.32",
     "react": "^18.3.1",
     "react-dom": "^18.3.1"
   }

package/src/client.ts

@@ -1,2 +0,0 @@
-'use client';
-export {LocaleContextProvider, useLocaleContext} from './i18n/LocaleContext';

package/src/common/ComponentRegistry.ts

@@ -1,159 +0,0 @@
-import type {
-    ComponentDefinition,
-    ComponentDefinitionParams,
-    ComponentDictionary,
-    PageComponent,
-    SelectedQueryMaybeVariablesFunc,
-    SelectorName
-} from '../types';
-
-
-import {CATCH_ALL, XP_COMPONENT_TYPE} from './constants';
-
-
-function toSelectorName(type: XP_COMPONENT_TYPE): SelectorName | undefined {
-    switch (type) {
-    case XP_COMPONENT_TYPE.PAGE:
-        return 'page';
-    case XP_COMPONENT_TYPE.LAYOUT:
-        return 'layout';
-    case XP_COMPONENT_TYPE.PART:
-        return 'part';
-    }
-}
-
-
-export class ComponentRegistry {
-
-    private static contentTypes: ComponentDictionary = {};
-    private static pages: ComponentDictionary = {};
-    private static components: ComponentDictionary = {};
-    private static parts: ComponentDictionary = {};
-    private static layouts: ComponentDictionary = {};
-    private static macros: ComponentDictionary = {};
-    private static commonQuery: SelectedQueryMaybeVariablesFunc;
-
-    public static addComponent(name: string, obj: ComponentDefinitionParams): void {
-        return ComponentRegistry.addType('component', name, obj);
-    }
-
-    public static addContentType(name: string, obj: ComponentDefinitionParams): void {
-        return ComponentRegistry.addType('contentType', name, obj);
-    }
-
-    public static addMacro(name: string, obj: ComponentDefinitionParams): void {
-        return ComponentRegistry.addType('macro', name, obj);
-    }
-
-    public static addLayout(name: string, obj: ComponentDefinitionParams): void {
-        return ComponentRegistry.addType('layout', name, obj);
-    }
-
-    public static addPage(name: string, obj: ComponentDefinitionParams): void {
-        return ComponentRegistry.addType('page', name, obj);
-    }
-
-    public static addPart(name: string, obj: ComponentDefinitionParams): void {
-        return ComponentRegistry.addType('part', name, obj);
-    }
-
-    private static addType(selectorName: SelectorName, name: string, obj: ComponentDefinitionParams): void {
-        const selector = ComponentRegistry.getSelector(selectorName);
-        const curr = selector[name];
-        selector[name] = curr ? Object.assign(curr, obj) : obj;
-    }
-
-    private static getSelector(name: SelectorName): ComponentDictionary {
-        switch (name) {
-        case 'contentType':
-            return this.contentTypes;
-        case 'page':
-            return this.pages;
-        case 'component':
-            return this.components;
-        case 'layout':
-            return this.layouts;
-        case 'part':
-            return this.parts;
-        case 'macro':
-            return this.macros;
-        }
-    }
-
-    private static getType(selectorName: SelectorName, typeName: string, useCatchAll = true): ComponentDefinition | undefined {
-        const selector = ComponentRegistry.getSelector(selectorName);
-        let type: ComponentDefinition|undefined = selector[typeName];
-        if (type) {
-            type.catchAll = typeName === CATCH_ALL;
-        } else if (!type && useCatchAll) {
-            type = selector[CATCH_ALL];
-            if (type) {
-                type.catchAll = true;
-            }
-        }
-        return type;
-    }
-
-    public static getByComponent(component: PageComponent): ComponentDefinition | undefined {
-        const selName = toSelectorName(component.type);
-        const cmpData = component[component.type];
-        const desc = cmpData && 'descriptor' in cmpData ? cmpData.descriptor : component.path;
-        return selName && desc ? this.getType(selName, desc) : undefined;
-    }
-
-    public static setCommonQuery(query: SelectedQueryMaybeVariablesFunc): void {
-        this.commonQuery = query;
-    }
-
-    public static getCommonQuery(): SelectedQueryMaybeVariablesFunc {
-        return this.commonQuery;
-    }
-
-    public static getMacro(name: string): ComponentDefinition | undefined {
-        return ComponentRegistry.getType('macro', name);
-    }
-
-    public static getMacros(): [string, ComponentDefinition][] {
-        return Object.entries(this.macros);
-    }
-
-    public static getParts(): [string, ComponentDefinition][] {
-        return Object.entries(this.parts);
-    }
-
-    public static getLayouts(): [string, ComponentDefinition][] {
-        return Object.entries(this.layouts);
-    }
-
-    public static getPages(): [string, ComponentDefinition][] {
-        return Object.entries(this.pages);
-    }
-
-    public static getContentTypes(): [string, ComponentDefinition][] {
-        return Object.entries(this.contentTypes);
-    }
-
-    public static getComponents(): [string, ComponentDefinition][] {
-        return Object.entries(this.components);
-    }
-
-    public static getContentType(name: string): ComponentDefinition | undefined {
-        return ComponentRegistry.getType('contentType', name);
-    }
-
-    public static getPage(name: string): ComponentDefinition | undefined {
-        return ComponentRegistry.getType('page', name);
-    }
-
-    public static getPart(name: string): ComponentDefinition | undefined {
-        return ComponentRegistry.getType('part', name);
-    }
-
-    public static getLayout(name: string): ComponentDefinition | undefined {
-        return ComponentRegistry.getType('layout', name);
-    }
-
-    public static getComponent(name: string): ComponentDefinition | undefined {
-        return ComponentRegistry.getType('component', name);
-    }
-}

package/src/guillotine/applyProcessors.ts

@@ -1,34 +0,0 @@
-import type {ComponentDescriptor, ContentResult, Context} from '../types';
-
-
-import {getComponentConfig} from './getComponentConfig';
-
-
-const NO_PROPS_PROCESSOR = async (props: any) => await props ?? {};
-
-
-export async function applyProcessors(
-    componentDescriptors: ComponentDescriptor[],
-    contentResults: ContentResult,
-    context: Context
-): Promise < PromiseSettledResult < any > [] > {
-
-    let dataCounter = 0;
-    const processorPromises = componentDescriptors.map(async (desc: ComponentDescriptor) => {
-        // we're iterating component descriptors here
-        // some of them might not have provided graphql requests
-        // but we still need to run props processor for them
-        // in case they want to fetch their data from elsewhere
-        const propsProcessor = desc.type?.processor || NO_PROPS_PROCESSOR;
-        let data;
-        if (desc.queryAndVariables) {
-            // if there is a query then there must be a result for it
-            data = contentResults.contents[dataCounter++];
-        }
-
-        const config = getComponentConfig(desc.component);
-        return await propsProcessor(data, context, config);
-    });
-
-    return Promise.allSettled(processorPromises);
-}

package/src/guillotine/buildPage.ts

@@ -1,15 +0,0 @@
-import type {PageComponent} from '../types';
-
-
-import {XP_COMPONENT_TYPE} from '../common/constants';
-import {buildComponentTree} from './buildComponentTree';
-
-
-export function buildPage(contentType: string, comps: PageComponent[] = []): PageComponent {
-    const page: PageComponent = {
-        type: XP_COMPONENT_TYPE.PAGE,
-        path: '/'
-    };
-
-    return buildComponentTree(comps, page, contentType);
-}

package/src/guillotine/createMetaData.ts

@@ -1,72 +0,0 @@
-import type {MetaData, PageComponent} from '../types';
-
-
-import {RENDER_MODE, XP_REQUEST_TYPE} from '../common/constants';
-import {ComponentRegistry} from '../common/ComponentRegistry';
-
-
-export function createMetaData({
-                                   apiUrl,
-                                   baseUrl,
-                                   components = [], // Optional NOTE: Doesn't handle null
-                                   contentPath,
-                                   contentType,
-                                   contentId,
-                                   defaultLocale,
-                                   locale,
-                                   pageCmp, // Optional
-                                   renderMode,
-                                   requestedComponentPath,
-    requestType
-                               }: {
-    apiUrl: string
-    baseUrl: string
-    components?: PageComponent[]
-    contentPath: string
-    contentId: string
-    contentType: string
-    defaultLocale: string
-    locale: string
-    pageCmp?: PageComponent
-    renderMode: RENDER_MODE
-    requestedComponentPath: string | undefined
-    requestType: XP_REQUEST_TYPE
-}): MetaData {
-    // .meta will be visible in final rendered inline props.
-    // Only adding some .meta attributes here on certain conditions
-    // (instead of always adding them and letting them be visible as false/undefined etc)
-    const meta: MetaData = {
-        apiUrl,
-        baseUrl,
-        canRender: false,
-        catchAll: false, // catchAll only refers to content type catch-all
-        defaultLocale,
-        locale,
-        id: contentId,
-        path: contentPath,
-        renderMode: renderMode,
-        requestType: requestType,
-        type: contentType
-    };
-
-    if (requestedComponentPath) {
-        meta.requestedComponent = components.find(cmp => cmp.path === requestedComponentPath);
-    }
-
-    const pageDesc = pageCmp?.page?.descriptor;
-    const typeDef = ComponentRegistry.getContentType(contentType);
-    if (typeDef?.view && !typeDef.catchAll) {
-        meta.canRender = true;
-    } else if (requestType === XP_REQUEST_TYPE.COMPONENT) {
-        // always render a single component (show missing if not implemented)
-        meta.canRender = true;
-    } else if (pageDesc) {
-        // always render a page if there is a descriptor (show missing if not implemented)
-        meta.canRender = true;
-    } else if (typeDef?.view) {
-        meta.canRender = true;
-        meta.catchAll = true;
-    }
-
-    return meta;
-}

package/src/guillotine/fetchContent.ts

@@ -1,240 +0,0 @@
-import type {ComponentDescriptor, Context, FetchContentResult} from '../types';
-
-import {draftMode, headers} from 'next/headers';
-import {ComponentRegistry} from '../common/ComponentRegistry';
-import {PAGE_TEMPLATE_CONTENTTYPE_NAME, PAGE_TEMPLATE_FOLDER, RENDER_MODE, XP_COMPONENT_TYPE, XP_REQUEST_TYPE} from '../common/constants';
-import {APP_NAME, APP_NAME_DASHED, IS_DEV_MODE} from '../common/env';
-import {getContentApiUrl} from '../utils/getContentApiUrl';
-import {getLocaleMapping} from '../utils/getLocaleMapping';
-import {getRenderMode} from '../utils/getRenderMode';
-import {getXpBaseUrl} from '../utils/getXpBaseUrl';
-import {getRequestLocaleInfo} from '../utils/getRequestLocaleInfo';
-import {buildGuillotineRequestHeaders} from '../utils/buildGuillotineRequestHeaders';
-
-import {buildPage} from './buildPage';
-import {fetchMetaData} from './fetchMetaData';
-import {getCleanContentPathArrayOrThrow400} from './getCleanContentPathArrayOrThrow400';
-import {buildErrorResponse} from './buildErrorResponse';
-import {getContentAndComponentPaths} from './getContentAndComponentPaths';
-import {restrictComponentsToPath} from './restrictComponentsToPath';
-import {processComponentConfig} from './processComponentConfig';
-import {getQueryAndVariables} from './getQueryAndVariables';
-import {collectComponentDescriptors} from './collectComponentDescriptors';
-import {combineMultipleQueries} from './combineMultipleQueries';
-import {fetchContentData} from './fetchContentData';
-import {applyProcessors} from './applyProcessors';
-import {createMetaData} from './createMetaData';
-
-
-/**
- * Default fetchContent function, built with params from imports.
- * It runs custom content-type-specific guillotine calls against an XP guillotine endpoint, returns content data, error and some meta data
- * Sends one query to the guillotine API and asks for content type, then uses the type to select a second query and variables, which is sent to the API and fetches content data.
- * @param context object from Next, contains .query info
- * @returns FetchContentResult object: {data?: T, error?: {code, message}}
- */
-export async function fetchContent(context: Context): Promise<FetchContentResult> {
-    const {locale, locales, defaultLocale} = getRequestLocaleInfo(context);
-    const {isEnabled} = await draftMode();
-
-    // we only want to read headers in draft mode, because they bail out static generation
-    if (isEnabled) {
-        const allHeaders = await headers();
-
-        if (!context.headers) {
-            context.headers = new Headers();
-        }
-        allHeaders.forEach((value, key) => {
-            context.headers.set(key, value);
-        });
-    }
-
-    const outHeaders = buildGuillotineRequestHeaders({
-        context,
-        defaultLocale,
-        locale,
-        locales
-    });
-    const xpBaseUrl = getXpBaseUrl(context);
-    const contentApiUrl = getContentApiUrl(context);
-    const mapping = getLocaleMapping(context);
-    const renderMode = getRenderMode(context);
-    let requestType = XP_REQUEST_TYPE.TYPE;
-    const requestContentPath = getCleanContentPathArrayOrThrow400(context.contentPath);
-
-    try {
-        const [siteRelativeContentPath, componentPath] = getContentAndComponentPaths(requestContentPath);
-        if (componentPath) {
-            // set component request type because url contains component path
-            requestType = XP_REQUEST_TYPE.COMPONENT;
-        }
-
-        // /////////////  FIRST GUILLOTINE CALL FOR METADATA     /////////////////
-        const metaResult = await fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, mapping, outHeaders);
-        // ///////////////////////////////////////////////////////////////////////
-
-        const {_id, _path, type} = metaResult.meta || {};
-        const contentPath = _path || siteRelativeContentPath;
-
-        const errorResponse = buildErrorResponse(requestType, renderMode, contentApiUrl, xpBaseUrl, locale, defaultLocale, requestContentPath, _id);
-
-        if (metaResult.error) {
-            console.error(metaResult.error);
-            return errorResponse(metaResult.error.code, metaResult.error.message);
-        }
-
-        if (!metaResult.meta) {
-            return errorResponse('404', 'No meta data found for content, most likely content does not exist');
-        } else if (!type) {
-            return errorResponse('500', "Server responded with incomplete meta data: missing content 'type' attribute.");
-
-        } else if (
-            renderMode === RENDER_MODE.NEXT
-            && !IS_DEV_MODE
-            && (
-                type === PAGE_TEMPLATE_CONTENTTYPE_NAME ||
-                type === PAGE_TEMPLATE_FOLDER
-            )) {
-            return errorResponse('404', `Content type [${type}] is not accessible in ${renderMode} mode`);
-        }
-
-        const components = restrictComponentsToPath(type, metaResult.meta.components, componentPath);
-        if (componentPath && !components.length) {
-            // component was not found
-            return errorResponse('404', `Component ${componentPath} was not found`);
-        }
-
-        if (requestType !== XP_REQUEST_TYPE.COMPONENT && components.length > 0) {
-            requestType = XP_REQUEST_TYPE.PAGE;
-        }
-
-        // //////////////////////////////////////////////////  Content type established. Proceed to data call:
-
-        const allDescriptors: ComponentDescriptor[] = [];
-
-        // Add the content type query at all cases
-        const contentTypeDef = ComponentRegistry.getContentType(type);
-        const pageCmp = (components || []).find(cmp => cmp.type === XP_COMPONENT_TYPE.PAGE);
-        if (pageCmp) {
-            processComponentConfig(APP_NAME, APP_NAME_DASHED, pageCmp);
-        }
-
-        const contentQueryAndVars = getQueryAndVariables(type, contentPath, context, contentTypeDef?.query, pageCmp?.page?.config);
-        if (contentQueryAndVars) {
-            allDescriptors.push({
-                type: contentTypeDef,
-                queryAndVariables: contentQueryAndVars
-            });
-        }
-
-        const commonQueryAndVars = getQueryAndVariables(type, contentPath, context, ComponentRegistry.getCommonQuery(),
-            pageCmp?.page?.config);
-        if (commonQueryAndVars) {
-            allDescriptors.push({
-                type: contentTypeDef,
-                queryAndVariables: commonQueryAndVars
-            });
-        }
-
-        if (components?.length && ComponentRegistry) {
-            for (const cmp of (components || [])) {
-                processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
-            }
-            // Collect component queries if defined
-            const componentDescriptors = collectComponentDescriptors({
-                components,
-                xpContentPath: contentPath,
-                context
-            });
-            if (componentDescriptors.length) {
-                allDescriptors.push(...componentDescriptors);
-            }
-        }
-
-        const {query, variables} = combineMultipleQueries(allDescriptors);
-        if (!query.trim()) {
-            return errorResponse('400', `Missing or empty query override for content type ${type}`);
-        }
-
-        // ///////////////    SECOND GUILLOTINE CALL FOR DATA   //////////////////////
-        const contentResults = await fetchContentData(contentApiUrl, contentPath, mapping, query, variables, outHeaders);
-        // ///////////////////////////////////////////////////////////////////////////
-
-        if (contentResults.error) {
-            console.error(contentResults.error);
-            return errorResponse(contentResults.error.code, contentResults.error.message);
-        }
-
-        // Apply processors to every component
-        const datas = await applyProcessors(allDescriptors, contentResults, context);
-
-        //  Unwind the data back to components
-
-        let contentData = null, common = null;
-        let startFrom = 0;
-        if (contentQueryAndVars) {
-            const item = datas[startFrom];
-            contentData = item.status === 'fulfilled' ? item.value : item.reason;
-            startFrom++;
-        }
-        if (commonQueryAndVars) {
-            const item = datas[startFrom];
-            common = item.status === 'fulfilled' ? item.value : item.reason;
-            startFrom++;
-        }
-
-        for (let i = startFrom; i < datas.length; i++) {
-            // component descriptors hold references to components
-            // that will later be used for creating page regions
-            const datum = datas[i];
-            if (datum.status === 'rejected') {
-                let reason = datum.reason;
-                if (reason instanceof Error) {
-                    reason = reason.message;
-                } else if (typeof reason !== 'string') {
-                    reason = String(reason);
-                }
-                allDescriptors[i].component.error = reason;
-            } else {
-                allDescriptors[i].component.data = datum.value;
-            }
-        }
-
-        const page = buildPage(type, components);
-        const meta = createMetaData({
-            apiUrl: contentApiUrl,
-            baseUrl: xpBaseUrl,
-            components,
-            contentPath: siteRelativeContentPath,
-            contentType: type,
-            contentId: _id,
-            defaultLocale,
-            locale,
-            pageCmp: page,
-            renderMode,
-            requestedComponentPath: componentPath,
-            requestType
-        });
-
-        return {
-            data: contentData,
-            common,
-            meta,
-            page
-        };
-    } catch (e: any) {
-        console.error(e);
-
-        let error;
-        try {
-            error = JSON.parse(e.message);
-        } catch (e2) {
-            error = {
-                code: 'Local',
-                message: e.message
-            };
-        }
-        const errorResponse = buildErrorResponse(requestType, renderMode, contentApiUrl, xpBaseUrl, locale, defaultLocale, requestContentPath);
-        return errorResponse(error.code, error.message);
-    }
-}