@enonic/nextjs-adapter 2.0.0 → 3.0.0-B1

package/UrlProcessor.d.ts

@@ -11,7 +11,7 @@ export declare class UrlProcessor {
     private static startSlashPattern;
     private static localhostPattern;
     private static siteKey;
-    static process(url: string, meta: MetaData, serverSide?: boolean): string;
+    static process(url: string, meta: MetaData, serverSide?: boolean, isResource?: boolean): string;
     static setSiteKey(key: string): void;
     static isMediaLink(ref: string, linkData: LinkData[]): boolean;
     static isContentImage(ref: string, linkData: ImageData[]): boolean;
@@ -22,4 +22,5 @@ export declare class UrlProcessor {
     private static isRelative;
     private static getApiUrl;
 }
-export declare const getUrl: (url: string, meta: MetaData, serverSide?: boolean) => string;
+export declare function getUrl(url: string, meta: MetaData): string;
+export declare function getAsset(url: string, meta: MetaData): string;

package/UrlProcessor.js

@@ -1,7 +1,7 @@
-import { commonChars, fixDoubleSlashes, getLocaleProjectConfigs, RENDER_MODE } from './utils';
+import { commonChars, fixDoubleSlashes, getProjectLocaleConfigById, RENDER_MODE } from './utils';
 import { addBasePath } from 'next/dist/client/add-base-path';
 export class UrlProcessor {
-    static process(url, meta, serverSide = false) {
+    static process(url, meta, serverSide = false, isResource = false) {
         if (this.startsWithHash(url) || !meta || (this.isAttachmentUrl(url)) && meta.renderMode === RENDER_MODE.NEXT) {
             // do not process if:
             // - url starts with #
@@ -9,15 +9,25 @@ export class UrlProcessor {
             // - attachment urls in NEXT mode
             return url;
         }
+        let normalUrl;
         let result;
-        const apiUrl = this.getApiUrl(meta);
-        const strippedUrl = this.stripApiUrl(url, apiUrl);
+        if (this.isRelative(url)) {
+            normalUrl = url;
+        }
+        else {
+            // url is absolute, try to make it relative by striping apiUrl
+            // NB: will fail if content api is not on the same domain as enonic xp
+            const apiUrl = this.getApiUrl(meta);
+            normalUrl = this.stripApiUrl(url, apiUrl);
+        }
         const baseUrl = (meta === null || meta === void 0 ? void 0 : meta.baseUrl) && (meta === null || meta === void 0 ? void 0 : meta.baseUrl) !== '/' ? meta.baseUrl : '';
         if (meta.renderMode === RENDER_MODE.NEXT) {
             // only add basePath and locale in next mode
-            result = `/${strippedUrl}`;
-            if (!this.isRelative(url) && meta.locale !== meta.defaultLocale) {
-                // do not append locale to local assets (having relative urls)
+            result = `/${normalUrl}`;
+            if (!isResource && meta.locale !== meta.defaultLocale) {
+                // append locale if it's not the default one
+                // to avoid additional middleware redirection
+                // NB: don't add locale to resource urls
                 result = `/${meta.locale}${result}`;
             }
             if (!serverSide) {
@@ -26,7 +36,7 @@ export class UrlProcessor {
             }
         }
         else {
-            result = `${baseUrl}/${strippedUrl}`;
+            result = `${baseUrl}/${normalUrl}`;
         }
         return fixDoubleSlashes(result);
     }
@@ -92,6 +102,11 @@ UrlProcessor.endSlashPattern = /\/+$/;
 UrlProcessor.startSlashPattern = /^\/+/;
 UrlProcessor.localhostPattern = /localhost/;
 // Actual site is going to be set in fetchContent method, but set a default fallback here too
-const defaultConfig = getLocaleProjectConfigs().default;
+const defaultConfig = getProjectLocaleConfigById();
 UrlProcessor.setSiteKey(defaultConfig.site);
-export const getUrl = UrlProcessor.process.bind(UrlProcessor);
+export function getUrl(url, meta) {
+    return UrlProcessor.process(url, meta, false, false);
+}
+export function getAsset(url, meta) {
+    return UrlProcessor.process(url, meta, false, true);
+}

package/guillotine/fetchContent.d.ts

@@ -1,6 +1,5 @@
 import { MetaData, PageComponent } from './getMetaData';
-import { ContentPathItem, Context, LocaleProjectConfig } from '../utils';
-import { GetServerSidePropsResult, GetStaticPropsResult } from 'next';
+import { ContentPathItem, Context, ProjectLocaleConfig } from '../utils';
 type Result = {
     error?: {
         code: string;
@@ -21,7 +20,7 @@ export type FetchContentResult = Result & {
  * @param contentPath string or string array: pre-split or slash-delimited _path to a content available on the API
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
-export type ContentFetcher = (contentPath: string | string[], context?: Context) => Promise<FetchContentResult>;
+export type ContentFetcher = (context: Context) => Promise<FetchContentResult>;
 export type ContentApiBaseBody = {
     query?: string;
     variables?: {
@@ -30,9 +29,9 @@ export type ContentApiBaseBody = {
     };
 };
 /** Generic fetch */
-export declare const fetchFromApi: (apiUrl: string, body: ContentApiBaseBody, projectConfig: LocaleProjectConfig, headers?: {}, method?: string) => Promise<any>;
+export declare const fetchFromApi: (apiUrl: string, body: ContentApiBaseBody, projectConfig: ProjectLocaleConfig, headers?: {}, method?: string) => Promise<any>;
 /** Guillotine-specialized fetch, using the generic fetch above */
-export declare const fetchGuillotine: (contentApiUrl: string, body: ContentApiBaseBody, projectConfig: LocaleProjectConfig, headers?: {}) => Promise<GuillotineResult>;
+export declare const fetchGuillotine: (contentApiUrl: string, body: ContentApiBaseBody, projectConfig: ProjectLocaleConfig, headers?: {}) => Promise<GuillotineResult>;
 /**
  * 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
@@ -42,8 +41,7 @@ export declare const fetchGuillotine: (contentApiUrl: string, body: ContentApiBa
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
 export declare const fetchContent: ContentFetcher;
-export declare function createResponse(props: FetchContentResult, context?: Context, isStatic?: true): GetStaticPropsResult<FetchContentResult>;
-export declare function createResponse(props: FetchContentResult, context?: Context, isStatic?: false): GetServerSidePropsResult<FetchContentResult>;
+export declare function validateData(props: FetchContentResult): void;
 export declare function fetchContentPathsForAllLocales(path: string, query?: string, countPerLocale?: number): Promise<ContentPathItem[]>;
-export declare function fetchContentPathsForLocale(path: string, config: LocaleProjectConfig, query?: string, count?: number): Promise<ContentPathItem[]>;
+export declare function fetchContentPathsForLocale(path: string, config: ProjectLocaleConfig, query?: string, count?: number): Promise<ContentPathItem[]>;
 export {};

package/guillotine/fetchContent.js

@@ -8,9 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { getMetaQuery, pageFragmentQuery } from './getMetaData';
-import adapterConstants, { addJsessionHeaders, addLocaleHeaders, APP_NAME, APP_NAME_DASHED, FRAGMENT_CONTENTTYPE_NAME, FRAGMENT_DEFAULT_REGION_NAME, GET_STATIC_PATHS_QUERY, getContentApiUrl, getLocaleProjectConfig, getLocaleProjectConfigs, getRenderMode, getXpBaseUrl, IS_DEV_MODE, normalizeLocale, PAGE_TEMPLATE_CONTENTTYPE_NAME, PAGE_TEMPLATE_FOLDER, PURGE_CACHE_URL, RENDER_MODE, sanitizeGraphqlName, XP_COMPONENT_TYPE, XP_REQUEST_TYPE, } from '../utils';
+import adapterConstants, { addJsessionHeaders, addLocaleHeaders, APP_NAME, APP_NAME_DASHED, FRAGMENT_CONTENTTYPE_NAME, FRAGMENT_DEFAULT_REGION_NAME, GET_STATIC_PATHS_QUERY, getContentApiUrl, getProjectLocaleConfig, getProjectLocaleConfigs, getRenderMode, getRequestLocaleInfo, getXpBaseUrl, IS_DEV_MODE, PAGE_TEMPLATE_CONTENTTYPE_NAME, PAGE_TEMPLATE_FOLDER, RENDER_MODE, sanitizeGraphqlName, XP_COMPONENT_TYPE, XP_REQUEST_TYPE, } from '../utils';
 import { ComponentRegistry } from '../ComponentRegistry';
-import { getUrl, UrlProcessor } from '../UrlProcessor';
+import { UrlProcessor } from '../UrlProcessor';
+import { notFound, redirect, RedirectType } from 'next/navigation';
+import { headers } from 'next/headers';
 const NO_PROPS_PROCESSOR = (props) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = yield props) !== null && _a !== void 0 ? _a : {}; });
 const ALIAS_PREFIX = 'request';
 const GUILLOTINE_QUERY_REGEXP = /^\s*query\s*(?:\((.*)*\))?\s*{\s*guillotine\s*{((?:.|\s)+)}\s*}\s*$/;
@@ -85,8 +87,7 @@ export const fetchGuillotine = (contentApiUrl, body, projectConfig, headers) =>
                 errors = [errors];
             }
             console.error(`${errors.length} error(s) when fetching data from: ${contentApiUrl}`);
-            console.error(`headers: ${JSON.stringify(headers, null, 2)}
-                variables: ${JSON.stringify(body.variables, null, 2)}`);
+            console.error(`headers: ${JSON.stringify(headers, null, 2)} \nvariables: ${JSON.stringify(body.variables, null, 2)}`);
             errors.forEach(error => {
                 console.error(error);
             });
@@ -381,7 +382,7 @@ function collectComponentDescriptors(components, componentRegistry, xpContentPat
             if (cmpDef) {
                 // const partPath = `${xpContentPath}/_component${cmp.path}`;
                 const config = getComponentConfig(cmp);
-                const queryAndVariables = getQueryAndVariables(cmp.type, xpContentPath, cmpDef.query, context, config);
+                const queryAndVariables = getQueryAndVariables(cmp.type, xpContentPath, context, cmpDef.query, config);
                 if (queryAndVariables) {
                     descriptors.push({
                         component: cmp,
@@ -429,7 +430,7 @@ function processComponentConfig(myAppName, myAppNameDashed, cmp) {
         }
     }
 }
-function getQueryAndVariables(type, path, selectedQuery, context, config) {
+function getQueryAndVariables(type, path, context, selectedQuery, config) {
     let query, getVariables;
     if (typeof selectedQuery === 'string' || typeof selectedQuery === 'function') {
         query = selectedQuery;
@@ -508,27 +509,29 @@ function createMetaData(contentType, contentPath, requestType, renderMode, apiUr
     }
     return meta;
 }
-function errorResponse(code = '500', message = 'Unknown error', requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, contentPath) {
-    return {
-        error: {
-            code,
-            message,
-        },
-        page: null,
-        common: null,
-        data: null,
-        meta: {
-            type: '',
-            requestType: requestType,
-            renderMode: renderMode,
-            path: contentPath || '',
-            canRender: false,
-            catchAll: false,
-            apiUrl,
-            baseUrl,
-            locale,
-            defaultLocale,
-        },
+function buildErrorResponse(requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, contentPath) {
+    return function (code = '500', message = 'Unknown error') {
+        return {
+            error: {
+                code,
+                message,
+            },
+            page: null,
+            common: null,
+            data: null,
+            meta: {
+                type: '',
+                requestType: requestType,
+                renderMode: renderMode,
+                path: contentPath || '',
+                canRender: false,
+                catchAll: false,
+                apiUrl,
+                baseUrl,
+                locale,
+                defaultLocale,
+            },
+        };
     };
 }
 function restrictComponentsToPath(contentType, components, componentPath) {
@@ -564,7 +567,7 @@ function restrictComponentsToPath(contentType, components, componentPath) {
     return result;
 }
 const COMPONENT_PATH_KEY = /\/?_\/component/; // first slash is optional for root components
-const getContentAndComponentPaths = (requestPath, context) => {
+const getContentAndComponentPaths = (requestPath) => {
     let contentPath, componentPath;
     if (COMPONENT_PATH_KEY.test(requestPath)) {
         [contentPath, componentPath] = requestPath.split(COMPONENT_PATH_KEY);
@@ -582,56 +585,61 @@ const getContentAndComponentPaths = (requestPath, context) => {
  */
 const buildContentFetcher = (config) => {
     const { APP_NAME, APP_NAME_DASHED, componentRegistry, } = config;
-    return (contentPathOrArray, context) => __awaiter(void 0, void 0, void 0, function* () {
+    return (context) => __awaiter(void 0, void 0, void 0, function* () {
         var _a, _b;
-        if (context.preview) {
-            populateEnonicHeaders(context);
+        const { locale, locales, defaultLocale } = getRequestLocaleInfo(context);
+        // ideally we only want to set headers in draft mode,
+        // but draft mode token is not passed in non-static mode
+        // so try to add them whenever they are absent
+        if (!context.headers) {
+            const allHeaders = headers();
+            context.headers = new Headers();
+            allHeaders.forEach((value, key) => {
+                context.headers.set(key, value);
+            });
         }
-        const headers = {};
-        addJsessionHeaders(headers, context);
-        addLocaleHeaders(headers, context);
+        const outHeaders = {};
+        addJsessionHeaders(outHeaders, context);
+        addLocaleHeaders(outHeaders, locale, locales, defaultLocale);
         const xpBaseUrl = getXpBaseUrl(context);
         const contentApiUrl = getContentApiUrl(context);
-        const projectConfig = getLocaleProjectConfig(context);
+        const projectConfig = getProjectLocaleConfig(context);
         const renderMode = getRenderMode(context);
         let requestType = XP_REQUEST_TYPE.TYPE;
+        const requestContentPath = getCleanContentPathArrayOrThrow400(context.contentPath);
+        const errorResponse = buildErrorResponse(requestType, renderMode, contentApiUrl, xpBaseUrl, locale, defaultLocale, requestContentPath);
         UrlProcessor.setSiteKey(projectConfig.site);
         try {
-            const requestContentPath = getCleanContentPathArrayOrThrow400(contentPathOrArray);
-            if ('/' + requestContentPath === PURGE_CACHE_URL) {
-                // return 404 for /_/cache/enonic/purge because it should've been handled by standalone endpoint
-                return errorResponse('404', 'Not found', requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, requestContentPath);
-            }
-            const [siteRelativeContentPath, componentPath] = getContentAndComponentPaths(requestContentPath, context);
+            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 = yield fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, projectConfig, headers);
+            const metaResult = yield fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, projectConfig, outHeaders);
             // ///////////////////////////////////////////////////////////////////////
             const { _path, type } = metaResult.meta || {};
             const contentPath = _path || siteRelativeContentPath;
             if (metaResult.error) {
                 console.error(metaResult.error);
-                return errorResponse(metaResult.error.code, metaResult.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                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', requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                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.", requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse('500', "Server responded with incomplete meta data: missing content 'type' attribute.");
             }
             else if (renderMode === RENDER_MODE.NEXT && !IS_DEV_MODE &&
                 (type === FRAGMENT_CONTENTTYPE_NAME ||
                     type === PAGE_TEMPLATE_CONTENTTYPE_NAME ||
                     type === PAGE_TEMPLATE_FOLDER)) {
-                return errorResponse('404', `Content type [${type}] is not accessible in ${renderMode} mode`, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                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`, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse('404', `Component ${componentPath} was not found`);
             }
             if (requestType !== XP_REQUEST_TYPE.COMPONENT && components.length > 0) {
                 requestType = XP_REQUEST_TYPE.PAGE;
@@ -644,14 +652,14 @@ const buildContentFetcher = (config) => {
             if (pageCmp) {
                 processComponentConfig(APP_NAME, APP_NAME_DASHED, pageCmp);
             }
-            const contentQueryAndVars = getQueryAndVariables(type, contentPath, contentTypeDef === null || contentTypeDef === void 0 ? void 0 : contentTypeDef.query, context, (_a = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _a === void 0 ? void 0 : _a.config);
+            const contentQueryAndVars = getQueryAndVariables(type, contentPath, context, contentTypeDef === null || contentTypeDef === void 0 ? void 0 : contentTypeDef.query, (_a = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _a === void 0 ? void 0 : _a.config);
             if (contentQueryAndVars) {
                 allDescriptors.push({
                     type: contentTypeDef,
                     queryAndVariables: contentQueryAndVars,
                 });
             }
-            const commonQueryAndVars = getQueryAndVariables(type, contentPath, componentRegistry.getCommonQuery(), context, (_b = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _b === void 0 ? void 0 : _b.config);
+            const commonQueryAndVars = getQueryAndVariables(type, contentPath, context, componentRegistry.getCommonQuery(), (_b = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _b === void 0 ? void 0 : _b.config);
             if (commonQueryAndVars) {
                 allDescriptors.push({
                     type: contentTypeDef,
@@ -670,14 +678,14 @@ const buildContentFetcher = (config) => {
             }
             const { query, variables } = combineMultipleQueries(allDescriptors);
             if (!query.trim()) {
-                return errorResponse('400', `Missing or empty query override for content type ${type}`, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse('400', `Missing or empty query override for content type ${type}`);
             }
             // ///////////////    SECOND GUILLOTINE CALL FOR DATA   //////////////////////
-            const contentResults = yield fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, headers);
+            const contentResults = yield fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, outHeaders);
             // ///////////////////////////////////////////////////////////////////////////
             if (contentResults.error) {
                 console.error(contentResults.error);
-                return errorResponse(contentResults.error.code, contentResults.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse(contentResults.error.code, contentResults.error.message);
             }
             // Apply processors to every component
             const datas = yield applyProcessors(allDescriptors, contentResults, context);
@@ -713,7 +721,7 @@ const buildContentFetcher = (config) => {
                 }
             }
             const page = createPageData(type, components);
-            const meta = createMetaData(type, siteRelativeContentPath, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, componentPath, page, components);
+            const meta = createMetaData(type, siteRelativeContentPath, requestType, renderMode, contentApiUrl, xpBaseUrl, locale, defaultLocale, componentPath, page, components);
             return {
                 data: contentData,
                 common,
@@ -733,7 +741,7 @@ const buildContentFetcher = (config) => {
                     message: e.message,
                 };
             }
-            return errorResponse(error.code, error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPathOrArray.toString());
+            return errorResponse(error.code, error.message);
         }
     });
 };
@@ -747,55 +755,52 @@ const buildContentFetcher = (config) => {
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
 export const fetchContent = buildContentFetcher(Object.assign(Object.assign({}, adapterConstants), { componentRegistry: ComponentRegistry }));
-export function createResponse(props, context, isStatic = true) {
-    var _a, _b, _c, _d;
+export function validateData(props) {
+    validateNotFound(props);
+    validateShortcut(props);
+}
+function validateNotFound(props) {
+    const { error } = props;
+    if (error) {
+        switch (error.code) {
+            case '404':
+                console.warn(error.code, error.message);
+                notFound();
+                break;
+            default:
+                console.error(error.code, error.message);
+                throw new Error(error.message);
+        }
+    }
+}
+function validateShortcut(props) {
+    var _a, _b, _c;
     const { data, meta, error } = props;
     const pageUrl = (_c = (_b = (_a = data === null || data === void 0 ? void 0 : data.get) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.target) === null || _c === void 0 ? void 0 : _c.pageUrl;
     if (meta.type === 'base:shortcut' && pageUrl) {
         if (meta.renderMode !== RENDER_MODE.NEXT) {
             // console.debug(`Returning 404 for shortcut in ${RENDER_MODE.NEXT} mode`);
             // do not show shortcut targets in preview/edit mode
-            return {
-                notFound: true,
-            };
+            console.warn(404, `Shortcuts are not available in ${RENDER_MODE.NEXT} render mode`);
+            notFound();
         }
-        const destination = getUrl(pageUrl, meta, true);
-        // console.debug('Redirecting to', destination);
-        return {
-            redirect: {
-                statusCode: 307,
-                destination,
-            },
-        };
+        const destination = UrlProcessor.process(pageUrl, meta, true);
+        console.debug(`Redirecting shortcut content [${meta.path}] to`, destination);
+        redirect(destination, RedirectType.replace);
     }
     // we can not set 418 for static paths,
     // but we can show 404 instead to be handled in CS
     const canNotRender = meta && !meta.canRender && meta.renderMode !== RENDER_MODE.EDIT;
     const catchAllInNextProdMode = (meta === null || meta === void 0 ? void 0 : meta.renderMode) === RENDER_MODE.NEXT && !IS_DEV_MODE && (meta === null || meta === void 0 ? void 0 : meta.catchAll);
-    const notFound = (error && error.code === '404') || ((_d = context.res) === null || _d === void 0 ? void 0 : _d.statusCode) === 404 || canNotRender || catchAllInNextProdMode || undefined;
-    // console.debug('Returning view ' + (notFound ? '(not found)' : ''));
-    const result = {
-        notFound,
-        props,
-    };
-    if (isStatic) {
-        result.revalidate = 3600; // In seconds, meaning every hour
+    const isNotFound = (error && error.code === '404') || canNotRender || catchAllInNextProdMode;
+    if (isNotFound) {
+        console.warn(404, `Can not render content at [${meta.path}]`);
+        notFound();
     }
-    return result;
-}
-function populateEnonicHeaders(context) {
-    const pd = context.previewData;
-    if (!pd) {
-        return;
-    }
-    const req = context.req || {};
-    req.headers = Object.assign(req.headers || {}, pd.headers);
-    context.params = Object.assign(context.params || {}, pd.params);
-    context.req = req;
 }
 export function fetchContentPathsForAllLocales(path, query = GET_STATIC_PATHS_QUERY, countPerLocale = 999) {
     return __awaiter(this, void 0, void 0, function* () {
-        const promises = Object.values(getLocaleProjectConfigs()).map(config => fetchContentPathsForLocale(path, config, query, countPerLocale));
+        const promises = Object.values(getProjectLocaleConfigs()).map(config => fetchContentPathsForLocale(path, config, query, countPerLocale));
         return Promise.all(promises).then(results => {
             return results.reduce((all, localePaths) => all.concat(localePaths), []);
         });
@@ -803,7 +808,10 @@ export function fetchContentPathsForAllLocales(path, query = GET_STATIC_PATHS_QU
 }
 export function fetchContentPathsForLocale(path, config, query = GET_STATIC_PATHS_QUERY, count = 999) {
     return __awaiter(this, void 0, void 0, function* () {
-        const contentApiUrl = getContentApiUrl({ locale: config.locale });
+        const contentApiUrl = getContentApiUrl({
+            contentPath: path,
+            locale: config.locale,
+        });
         const body = {
             query,
             variables: {
@@ -817,10 +825,8 @@ export function fetchContentPathsForLocale(path, config, query = GET_STATIC_PATH
                 const regexp = new RegExp(`/${(_a = child.site) === null || _a === void 0 ? void 0 : _a._name}/?`);
                 const contentPath = child._path.replace(regexp, '');
                 prev.push({
-                    params: {
-                        contentPath: contentPath.split('/'),
-                    },
-                    locale: normalizeLocale(config.locale),
+                    contentPath: contentPath.split('/'),
+                    locale: config.locale,
                 });
                 return prev;
             }, []);

package/i18n/LocaleContext.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { Dict } from './i18n';
+export type LocaleContextType = {
+    setLocale: (locale: string) => void;
+    locale: string;
+    dictionary: Dict;
+    localize: (key: string, ...args: any[]) => string;
+};
+export declare const useLocaleContext: () => LocaleContextType;
+export declare const LocaleContextProvider: ({ children, locale }: {
+    children: any;
+    locale?: string;
+}) => React.JSX.Element;

package/i18n/LocaleContext.jsx

@@ -0,0 +1,42 @@
+'use client';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React, { createContext, useContext, useState } from 'react';
+import { getPhrase, loadPhrases } from './i18n';
+const LocaleContext = createContext({
+    setLocale: (locale) => {
+    },
+    locale: '',
+    dictionary: {},
+    localize: (key, ...args) => key,
+});
+export const useLocaleContext = () => useContext(LocaleContext);
+export const LocaleContextProvider = ({ children, locale }) => {
+    const [currentLocale, setLocaleState] = useState(locale);
+    const [dictionary, setPhrasesState] = useState({});
+    const setLocale = (locale) => __awaiter(void 0, void 0, void 0, function* () {
+        setLocaleState(locale);
+        return loadPhrases(locale).then((phrases) => {
+            setPhrasesState(phrases);
+            console.info(`Loaded client-side phrases for locale "${locale}"`);
+            return phrases;
+        });
+    });
+    if (locale && currentLocale !== locale) {
+        // async/await is not supported in client components yet
+        void setLocale(locale);
+    }
+    const localize = (key, ...args) => getPhrase(currentLocale, dictionary, key, ...args);
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    <LocaleContext.Provider value={{ setLocale, locale: currentLocale, dictionary, localize }}>
+            {children}
+        </LocaleContext.Provider>);
+};

package/i18n/i18n.d.ts

@@ -0,0 +1,13 @@
+export type Dict = {
+    [key: string]: string;
+};
+export declare class I18n {
+    private static locale;
+    private static dictionary;
+    static setLocale(locale: string): Promise<Dict>;
+    static localize(key: string, ...args: any[]): string;
+    static getLocale(): string;
+    static getDictionary(): Dict;
+}
+export declare const loadPhrases: (locale: string) => Promise<Dict>;
+export declare const getPhrase: (locale: string, dict: Dict, key: string, ...args: any[]) => string;

package/i18n/i18n.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class I18n {
+    static setLocale(locale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.locale = locale;
+            return loadPhrases(locale).then((phrases) => {
+                this.dictionary = phrases;
+                console.info(`Loaded server-side phrases for locale "${locale}"`);
+                return phrases;
+            });
+        });
+    }
+    static localize(key, ...args) {
+        return getPhrase(this.locale, this.dictionary, key, ...args);
+    }
+    static getLocale() {
+        return this.locale;
+    }
+    static getDictionary() {
+        return this.dictionary;
+    }
+}
+I18n.locale = '';
+I18n.dictionary = {};
+export const loadPhrases = (locale) => __awaiter(void 0, void 0, void 0, function* () {
+    return import(`@phrases/${locale}.json`)
+        .then((module) => module.default)
+        .catch((e) => {
+        console.error(`Failed to load phrases for locale "${locale}"`, e);
+        return {};
+    });
+});
+export const getPhrase = (locale, dict, key, ...args) => {
+    const template = dict[key];
+    if (!template) {
+        console.warn(`Missing localization phrase for locale "${locale}": <${key}>`);
+        return `<${key}>`;
+    }
+    if (args === null || args === void 0 ? void 0 : args.length) {
+        let index = -1;
+        return template.replace(/{(\d+)?}/g, (match, digit) => {
+            var _a;
+            index++;
+            return (_a = args[digit || index]) !== null && _a !== void 0 ? _a : match;
+        });
+    }
+    return template;
+};

package/index.d.ts

@@ -3,3 +3,5 @@ export * from './guillotine/fetchContent';
 export * from './guillotine/getMetaData';
 export * from './ComponentRegistry';
 export * from './UrlProcessor';
+export * from './i18n/i18n';
+export * from './i18n/LocaleContext';

package/index.js

@@ -3,3 +3,5 @@ export * from './guillotine/fetchContent';
 export * from './guillotine/getMetaData';
 export * from './ComponentRegistry';
 export * from './UrlProcessor';
+export * from './i18n/i18n';
+export * from './i18n/LocaleContext';