@fecommunity/reactpress-toolkit 3.0.4 → 3.1.0

package/dist/theme/content/carouselArticles.d.ts

@@ -0,0 +1,10 @@
+import type { IArticle } from '../../types';
+import { type CarouselArticle } from './articleSlim';
+export declare const CAROUSEL_MAX_SLIDES = 6;
+export type ResolveCarouselArticlesOptions = {
+    /** Fetch recommended articles when the first page has fewer than {@link CAROUSEL_MAX_SLIDES} marked recommended. */
+    fetchRecommended?: () => Promise<IArticle[]>;
+    maxSlides?: number;
+};
+/** Resolve homepage carousel data with at most one recommend API call. */
+export declare function resolveCarouselArticles(rawArticles: IArticle[], options?: ResolveCarouselArticlesOptions): Promise<CarouselArticle[]>;

package/dist/theme/content/carouselArticles.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAROUSEL_MAX_SLIDES = void 0;
+exports.resolveCarouselArticles = resolveCarouselArticles;
+const articleSlim_1 = require("./articleSlim");
+exports.CAROUSEL_MAX_SLIDES = 6;
+function mergeCarouselArticles(primary, extra, maxSlides) {
+    const merged = [];
+    const seen = new Set();
+    for (const article of [...primary, ...extra]) {
+        if (!article.cover || seen.has(article.id))
+            continue;
+        seen.add(article.id);
+        merged.push(article);
+        if (merged.length >= maxSlides)
+            break;
+    }
+    return merged;
+}
+/** Resolve homepage carousel data with at most one recommend API call. */
+async function resolveCarouselArticles(rawArticles, options = {}) {
+    const maxSlides = options.maxSlides ?? exports.CAROUSEL_MAX_SLIDES;
+    const fromFirstPage = rawArticles.filter((article) => article.isRecommended && article.cover);
+    if (fromFirstPage.length >= maxSlides) {
+        return (0, articleSlim_1.slimArticlesForCarousel)(fromFirstPage.slice(0, maxSlides));
+    }
+    if (!rawArticles.some((article) => article.cover)) {
+        return [];
+    }
+    let merged = fromFirstPage;
+    if (merged.length < maxSlides && options.fetchRecommended) {
+        const recommended = await options.fetchRecommended().catch(() => []);
+        merged = mergeCarouselArticles(merged, recommended, maxSlides);
+    }
+    if (merged.length === 0) {
+        return [];
+    }
+    return (0, articleSlim_1.slimArticlesForCarousel)(merged.slice(0, maxSlides));
+}

package/dist/theme/content/excerpt.d.ts

@@ -0,0 +1,15 @@
+import { stripHtml, truncateWords } from '../../utils/string';
+export type ArchiveExcerptMode = 'excerpt' | 'full' | 'none';
+export { stripHtml, truncateWords };
+export interface ResolveArchiveExcerptOptions {
+    mode?: ArchiveExcerptMode;
+    content?: string | null;
+    html?: string | null;
+    summary?: string | null;
+    wordLimit?: number;
+}
+/**
+ * Resolve archive list excerpt text from customizer `archiveExcerpt` mode.
+ * Returns `null` when the excerpt should be hidden.
+ */
+export declare function resolveArchiveExcerpt({ mode, content, html, summary, wordLimit, }: ResolveArchiveExcerptOptions): string | null;

package/dist/theme/content/excerpt.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateWords = exports.stripHtml = void 0;
+exports.resolveArchiveExcerpt = resolveArchiveExcerpt;
+const string_1 = require("../../utils/string");
+Object.defineProperty(exports, "stripHtml", { enumerable: true, get: function () { return string_1.stripHtml; } });
+Object.defineProperty(exports, "truncateWords", { enumerable: true, get: function () { return string_1.truncateWords; } });
+const DEFAULT_EXCERPT_WORD_LIMIT = 55;
+/** Plain text from Markdown when only `content` is available (no rendered `html`). */
+function stripMarkdown(markdown) {
+    return markdown
+        .replace(/^<!--[\s\S]*?-->$/gm, '')
+        .replace(/^#+\s+.*$/gm, '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/~~([^~]+)~~/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/^\d+\.\s+/gm, '')
+        .replace(/^>\s+.*/gm, '')
+        .replace(/^---$/gm, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .replace(/!\[[^\]]*\]\([^)]+\)/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Resolve archive list excerpt text from customizer `archiveExcerpt` mode.
+ * Returns `null` when the excerpt should be hidden.
+ */
+function resolveArchiveExcerpt({ mode = 'excerpt', content, html, summary, wordLimit = DEFAULT_EXCERPT_WORD_LIMIT, }) {
+    if (mode === 'none')
+        return null;
+    const raw = summary?.trim() ||
+        (0, string_1.stripHtml)(html ?? '') ||
+        stripMarkdown(content ?? '') ||
+        '';
+    if (!raw)
+        return null;
+    if (mode === 'full')
+        return raw;
+    return (0, string_1.truncateWords)(raw, wordLimit);
+}

package/dist/theme/content/nav.d.ts

@@ -0,0 +1,10 @@
+export interface NavItem {
+    id: string;
+    href: string;
+    label: string;
+}
+/** Resolve active nav item id from pathname (exact match, then longest prefix). */
+export declare function getNavActiveId(pathname: string, items: NavItem[]): string | undefined;
+export declare function articlePath(id: string): string;
+export declare function categoryPath(value: string): string;
+export declare function tagPath(value: string): string;

package/dist/theme/content/nav.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNavActiveId = getNavActiveId;
+exports.articlePath = articlePath;
+exports.categoryPath = categoryPath;
+exports.tagPath = tagPath;
+/** Resolve active nav item id from pathname (exact match, then longest prefix). */
+function getNavActiveId(pathname, items) {
+    const path = pathname.split('?')[0].replace(/\/$/, '') || '/';
+    const normalized = items.map((item) => ({
+        ...item,
+        href: item.href.replace(/\/$/, '') || '/',
+    }));
+    const exact = normalized.find((item) => item.href === path);
+    if (exact)
+        return exact.id;
+    const prefixMatches = normalized
+        .filter((item) => item.href !== '/' && path.startsWith(item.href))
+        .sort((a, b) => b.href.length - a.href.length);
+    return prefixMatches[0]?.id;
+}
+function articlePath(id) {
+    return `/article/${id}`;
+}
+function categoryPath(value) {
+    return `/category/${value}`;
+}
+function tagPath(value) {
+    return `/tag/${value}`;
+}

package/dist/theme/content/seo.d.ts

@@ -0,0 +1,6 @@
+export interface SiteTitleSource {
+    systemTitle?: string;
+    systemSubTitle?: string;
+}
+export declare function getSiteTitle(setting: SiteTitleSource, fallback?: string): string;
+export declare function getPageTitle(pageTitle: string, setting: Pick<SiteTitleSource, 'systemTitle'>, fallback?: string): string;

package/dist/theme/content/seo.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSiteTitle = getSiteTitle;
+exports.getPageTitle = getPageTitle;
+function getSiteTitle(setting, fallback = 'ReactPress') {
+    const main = setting.systemTitle || fallback;
+    return setting.systemSubTitle ? `${main} - ${setting.systemSubTitle}` : main;
+}
+function getPageTitle(pageTitle, setting, fallback = 'ReactPress') {
+    const site = setting.systemTitle || fallback;
+    return `${pageTitle} - ${site}`;
+}

package/dist/theme/createAntdApp.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Full-featured Ant Design theme `_app` factory.
+ *
+ * @param {object} manifest — theme.json manifest (id + options for preview)
+ * @param {object} options
+ * @param {React.ComponentType} options.Layout — shell component receiving `{ children, needFooter, hasBg, needHeader }`
+ * @param {(mods: object) => string} [options.buildAppearanceCss] — inject customizer CSS
+ * @param {object} [options.httpClientOptions] — passed to `createThemeAxiosClient`
+ * @param {React.ComponentType} options.IntlProvider — `NextIntlProvider` from the theme's `next-intl` install
+ * @param {boolean} [options.scrollToTopOnRouteChange=true]
+ */
+export function createAntdThemeApp(manifest: object, options?: {
+    Layout: React.ComponentType;
+    buildAppearanceCss?: ((mods: object) => string) | undefined;
+    httpClientOptions?: object | undefined;
+    IntlProvider: React.ComponentType;
+    scrollToTopOnRouteChange?: boolean | undefined;
+}): {
+    new (props: any): {
+        state: {
+            locale: string;
+            user: null;
+            theme: import("./visitor/colorMode").ThemeColorMode;
+            collapsed: boolean;
+            setting: null;
+        };
+        changeLocale: (key: any) => void;
+        setUser: (user: any) => void;
+        removeUser: () => void;
+        changeTheme: (nextTheme: any) => void;
+        getSetting: () => void;
+        toggleCollapse: () => void;
+        componentDidMount(): void;
+        componentDidUpdate(_prevProps: any, prevState: any): void;
+        render(): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+        context: unknown;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<any>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    new (props: any, context: any): {
+        state: {
+            locale: string;
+            user: null;
+            theme: import("./visitor/colorMode").ThemeColorMode;
+            collapsed: boolean;
+            setting: null;
+        };
+        changeLocale: (key: any) => void;
+        setUser: (user: any) => void;
+        removeUser: () => void;
+        changeTheme: (nextTheme: any) => void;
+        getSetting: () => void;
+        toggleCollapse: () => void;
+        componentDidMount(): void;
+        componentDidUpdate(_prevProps: any, prevState: any): void;
+        render(): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+        context: unknown;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<any>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    getInitialProps: (appContext: any) => Promise<{
+        pageProps: any;
+        setting: Record<string, unknown>;
+        tags: unknown[];
+        categories: unknown[];
+        pages: unknown[];
+        i18n: Record<string, unknown>;
+        globalSetting: Record<string, unknown> | undefined;
+        siteConfig: Record<string, unknown>;
+        locales: string[];
+        initialLocale: string;
+        colorPrimary: string;
+        themeMods: import("./extension").ThemeMods;
+    }>;
+    origGetInitialProps: ({ Component, ctx, }: import("next/app").AppContext) => Promise<import("next/app").AppInitialProps>;
+    contextType?: React.Context<any> | undefined;
+};
+import React = require("react");

package/dist/theme/createAntdApp.js

@@ -0,0 +1,175 @@
+"use strict";
+const React = require('react');
+const App = require('next/app').default;
+const Router = require('next/router').default;
+const { ConfigProvider, theme: antdTheme } = require('antd');
+const { fetchAppBootstrap } = require('./ssr/bootstrap');
+const { createThemeAxiosClient } = require('./api/httpClient');
+const { createThemeProviders } = require('./providers');
+const { appearancePrimaryColorForMode } = require('./extension');
+const { applyColorModeClass, resolveClientThemeMode, resolveInitialColorModeState, persistVisitorLocale, } = require('./visitor/colorMode');
+const { clearThemeSession, persistThemeSession, resolveStoredUser, } = require('./visitor/authSession');
+const { AntdStyleTransitionFix } = require('../ui/components/AntdStyleTransitionFix');
+const { RouteProgress } = require('../ui/components/RouteProgress');
+const { SiteAnalytics } = require('../ui/components/SiteAnalytics');
+const { SiteCatalogProvider } = require('../ui/context/SiteCatalogContext');
+const { useReportPageView } = require('../ui/hooks/useReportPageView');
+function readInitialColorMode() {
+    if (typeof window === 'undefined')
+        return 'light';
+    return resolveClientThemeMode();
+}
+function ViewStatisticsBridge() {
+    useReportPageView();
+    return null;
+}
+/**
+ * Full-featured Ant Design theme `_app` factory.
+ *
+ * @param {object} manifest — theme.json manifest (id + options for preview)
+ * @param {object} options
+ * @param {React.ComponentType} options.Layout — shell component receiving `{ children, needFooter, hasBg, needHeader }`
+ * @param {(mods: object) => string} [options.buildAppearanceCss] — inject customizer CSS
+ * @param {object} [options.httpClientOptions] — passed to `createThemeAxiosClient`
+ * @param {React.ComponentType} options.IntlProvider — `NextIntlProvider` from the theme's `next-intl` install
+ * @param {boolean} [options.scrollToTopOnRouteChange=true]
+ */
+function createAntdThemeApp(manifest, options = {}) {
+    var _a;
+    const { Layout, buildAppearanceCss, httpClientOptions = {}, scrollToTopOnRouteChange = true, IntlProvider, } = options;
+    if (!Layout) {
+        throw new Error('createAntdThemeApp: options.Layout is required');
+    }
+    if (!IntlProvider) {
+        throw new Error('createAntdThemeApp: options.IntlProvider is required — import { NextIntlProvider } from "next-intl" in your theme');
+    }
+    if (scrollToTopOnRouteChange) {
+        Router.events.on('routeChangeComplete', () => {
+            setTimeout(() => {
+                if (document.documentElement.scrollTop > 0) {
+                    window.scrollTo({ top: 0, behavior: 'smooth' });
+                }
+            }, 0);
+        });
+    }
+    class AntdThemeApp extends App {
+        constructor() {
+            super(...arguments);
+            this.state = {
+                locale: '',
+                user: null,
+                theme: readInitialColorMode(),
+                collapsed: false,
+                setting: null,
+            };
+            this.changeLocale = (key) => {
+                persistVisitorLocale(key);
+                window.location.reload();
+            };
+            this.setUser = (user) => {
+                persistThemeSession(user);
+                this.setState({ user });
+            };
+            this.removeUser = () => {
+                clearThemeSession();
+                this.setState({ user: null });
+                window.location.reload();
+            };
+            this.changeTheme = (nextTheme) => {
+                applyColorModeClass(nextTheme === 'dark');
+                this.setState({ theme: nextTheme });
+            };
+            this.getSetting = () => {
+                const http = createThemeAxiosClient(httpClientOptions);
+                const { SettingProvider } = createThemeProviders(http);
+                SettingProvider.getSetting().then((res) => {
+                    this.setState({ setting: res });
+                });
+            };
+            this.toggleCollapse = () => {
+                this.setState({ collapsed: !this.state.collapsed });
+            };
+        }
+        componentDidMount() {
+            const user = resolveStoredUser();
+            if (user) {
+                persistThemeSession(user);
+                this.setState({ user });
+            }
+            const preferred = resolveInitialColorModeState() ?? 'light';
+            applyColorModeClass(preferred === 'dark');
+            if (this.state.theme !== preferred) {
+                this.setState({ theme: preferred });
+            }
+        }
+        componentDidUpdate(_prevProps, prevState) {
+            if (prevState.theme !== this.state.theme) {
+                applyColorModeClass(this.state.theme === 'dark');
+            }
+        }
+        render() {
+            const { Component, pageProps, i18n, globalSetting, siteConfig, locales, initialLocale, tags, categories, pages, colorPrimary: bootstrapColorPrimary, themeMods = {}, ...rest } = this.props;
+            const locale = this.state.locale ||
+                initialLocale ||
+                (Array.isArray(locales) && locales.length > 0 ? locales[0] : null) ||
+                'zh';
+            const { needLayoutFooter = true, hasBg = false } = pageProps;
+            const message = i18n?.[locale] || {};
+            const isDark = this.state.theme === 'dark';
+            const algorithm = isDark ? antdTheme.darkAlgorithm : antdTheme.defaultAlgorithm;
+            const colorPrimary = bootstrapColorPrimary ?? appearancePrimaryColorForMode(themeMods, isDark);
+            const appearanceCss = buildAppearanceCss?.(themeMods);
+            const setting = this.state.setting ?? rest.setting;
+            const catalogValue = {
+                setting,
+                i18n,
+                locale,
+                locales,
+                globalSetting,
+                siteConfig,
+                tags,
+                categories,
+                pages,
+                theme: this.state.theme,
+                collapsed: this.state.collapsed,
+                changeLocale: this.changeLocale,
+                user: this.state.user,
+                setUser: this.setUser,
+                removeUser: this.removeUser,
+                changeTheme: this.changeTheme,
+                getSetting: this.getSetting,
+                toggleCollapse: this.toggleCollapse,
+            };
+            return React.createElement(SiteCatalogProvider, { value: catalogValue }, React.createElement(IntlProvider, { messages: message, locale }, appearanceCss
+                ? React.createElement('style', {
+                    dangerouslySetInnerHTML: { __html: appearanceCss },
+                })
+                : null, React.createElement(AntdStyleTransitionFix, null), React.createElement(ViewStatisticsBridge, null), React.createElement(SiteAnalytics, null), React.createElement(ConfigProvider, {
+                locale: { locale },
+                theme: {
+                    token: { colorPrimary },
+                    algorithm,
+                },
+            }, React.createElement(Layout, {
+                needHeader: true,
+                needFooter: needLayoutFooter,
+                hasBg,
+            }, React.createElement(RouteProgress, null), React.createElement(Component, pageProps)))));
+        }
+    }
+    _a = AntdThemeApp;
+    AntdThemeApp.getInitialProps = async (appContext) => {
+        const appProps = await App.getInitialProps(appContext);
+        const bootstrap = await fetchAppBootstrap({
+            manifest,
+            ctx: appContext.ctx,
+        });
+        return {
+            ...appProps,
+            ...bootstrap,
+            pageProps: appProps.pageProps,
+        };
+    };
+    return AntdThemeApp;
+}
+module.exports = { createAntdThemeApp };

package/dist/theme/createApp.d.ts

@@ -0,0 +1,10 @@
+export function createThemeApp(manifest: any): {
+    ({ Component, pageProps }: {
+        Component: any;
+        pageProps: any;
+    }): React.FunctionComponentElement<import(".").ReactPressProviderProps>;
+    getInitialProps(appContext: any): Promise<{
+        pageProps: any;
+    }>;
+};
+import React = require("react");

package/dist/theme/createApp.js

@@ -0,0 +1,141 @@
+"use strict";
+const React = require('react');
+const App = require('next/app').default;
+const { fetchVisitorContext, createDefaultVisitorContext } = require('./ssr/fetch');
+const { themeApi } = require('./api/api');
+const { ReactPressProvider } = require('../ui/context/ReactPressProvider');
+const { ThemeCssVars } = require('../ui/components/ThemeCssVars');
+const { parsePreviewTokenFromNextCtx, PREVIEW_TOKEN_QUERY_KEY } = require('./preview/preview-draft');
+const { fetchPreviewDraft } = require('./extension/preview');
+const { mergePreviewMods } = require('./preview/preview-mods');
+function readPreviewTokenFromBrowser() {
+    if (typeof window === 'undefined')
+        return '';
+    return new URLSearchParams(window.location.search).get(PREVIEW_TOKEN_QUERY_KEY)?.trim() ?? '';
+}
+/** Dev-only: recover from stale webpack chunks after on-demand page compilation. */
+function DevChunkRecovery() {
+    React.useEffect(() => {
+        if (process.env.NODE_ENV !== 'development')
+            return undefined;
+        const storageKey = '__reactpress_dev_chunk_recover';
+        const maxAttempts = 2;
+        const isChunkMismatch = (message) => {
+            const msg = String(message || '');
+            return (msg.includes("reading 'call'") ||
+                msg.includes('ChunkLoadError') ||
+                msg.includes('Loading chunk') ||
+                msg.includes('__webpack_modules__'));
+        };
+        const recover = () => {
+            const attempts = Number(window.sessionStorage.getItem(storageKey) || 0);
+            if (attempts >= maxAttempts)
+                return;
+            window.sessionStorage.setItem(storageKey, String(attempts + 1));
+            window.location.reload();
+        };
+        const onError = (event) => {
+            const msg = event?.message || event?.reason?.message || event?.reason || '';
+            if (!isChunkMismatch(msg))
+                return;
+            if (typeof event.preventDefault === 'function')
+                event.preventDefault();
+            recover();
+        };
+        window.addEventListener('error', onError);
+        window.addEventListener('unhandledrejection', onError);
+        const Router = require('next/router').default;
+        const clearRecoveries = () => window.sessionStorage.removeItem(storageKey);
+        const onRouteError = (err) => {
+            if (err?.cancelled)
+                return;
+            if (isChunkMismatch(err?.message))
+                recover();
+        };
+        Router.events.on('routeChangeComplete', clearRecoveries);
+        Router.events.on('routeChangeError', onRouteError);
+        return () => {
+            window.removeEventListener('error', onError);
+            window.removeEventListener('unhandledrejection', onError);
+            Router.events.off('routeChangeComplete', clearRecoveries);
+            Router.events.off('routeChangeError', onRouteError);
+        };
+    }, []);
+    return null;
+}
+function createThemeApp(manifest) {
+    function ThemeApp({ Component, pageProps }) {
+        const { reactPress, ...rest } = pageProps;
+        const visitorContext = reactPress ?? createDefaultVisitorContext(manifest.id);
+        const [mods, setMods] = React.useState(() => visitorContext.mods ?? {});
+        React.useEffect(() => {
+            const base = visitorContext.mods ?? {};
+            const token = readPreviewTokenFromBrowser();
+            if (!token) {
+                setMods(base);
+                return undefined;
+            }
+            let cancelled = false;
+            void fetchPreviewDraft(token).then((draft) => {
+                if (cancelled)
+                    return;
+                setMods(mergePreviewMods(base, draft.mods ?? {}));
+            });
+            return () => {
+                cancelled = true;
+            };
+        }, [reactPress, visitorContext.mods]);
+        const providerProps = {
+            ...visitorContext,
+            mods,
+            isPreview: visitorContext.isPreview || Boolean(readPreviewTokenFromBrowser()),
+        };
+        return React.createElement(ReactPressProvider, providerProps, React.createElement(DevChunkRecovery, null), React.createElement(ThemeCssVars, null), React.createElement(Component, rest));
+    }
+    ThemeApp.getInitialProps = async (appContext) => {
+        const appProps = await App.getInitialProps(appContext);
+        const req = appContext.ctx.req;
+        const cookieHeader = req?.headers?.cookie ?? '';
+        const cookieLocale = /(?:^|;\s*)reactpress-locale=([^;]+)/.exec(cookieHeader)?.[1];
+        const acceptLanguage = typeof req?.headers?.['accept-language'] === 'string'
+            ? req.headers['accept-language']
+            : undefined;
+        let reactPress = createDefaultVisitorContext(manifest.id);
+        try {
+            reactPress = await fetchVisitorContext(themeApi, {
+                themeId: manifest.id,
+                preferredLocale: cookieLocale,
+                acceptLanguage,
+                // Visitor site must follow DB activeTheme only — not admin previewThemeId.
+                honorPreview: process.env.REACTPRESS_HONOR_PREVIEW === '1',
+            });
+        }
+        catch (error) {
+            const code = error?.code ?? error?.cause?.code;
+            if (code === 'ECONNREFUSED') {
+                console.warn('[reactpress] API unavailable during startup, using default visitor context');
+            }
+            else {
+                console.error('[reactpress] fetchVisitorContext failed', error);
+            }
+        }
+        const previewToken = parsePreviewTokenFromNextCtx(appContext.ctx);
+        if (previewToken) {
+            const draft = await fetchPreviewDraft(previewToken);
+            reactPress = {
+                ...reactPress,
+                mods: mergePreviewMods(reactPress.mods ?? {}, draft.mods ?? {}),
+                isPreview: true,
+            };
+        }
+        return {
+            ...appProps,
+            pageProps: {
+                ...appProps.pageProps,
+                reactPress,
+            },
+        };
+    };
+    return ThemeApp;
+}
+module.exports = { createThemeApp };