@fecommunity/reactpress 4.0.0-beta.0 → 4.0.0-beta.10

package/toolkit/dist/theme/colorMode.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorModeInitScript = exports.COLOR_MODE_STORAGE_KEY = void 0;
+exports.resolvePreferredColorMode = resolvePreferredColorMode;
+exports.applyColorModeClass = applyColorModeClass;
+exports.persistColorMode = persistColorMode;
+exports.resolveInitialColorModeState = resolveInitialColorModeState;
+exports.buildColorModeInitScript = buildColorModeInitScript;
+exports.COLOR_MODE_STORAGE_KEY = 'dark';
+function resolvePreferredColorMode() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    const storageTheme = window.localStorage.getItem(exports.COLOR_MODE_STORAGE_KEY);
+    if (storageTheme != null) {
+        return storageTheme === '1';
+    }
+    return window.matchMedia?.('(prefers-color-scheme: dark)').matches ?? false;
+}
+function applyColorModeClass(isDark, className = 'dark') {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    document.body.classList.toggle(className, isDark);
+    document.documentElement.style.colorScheme = isDark ? 'dark' : 'light';
+}
+function persistColorMode(isDark) {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    window.localStorage.setItem(exports.COLOR_MODE_STORAGE_KEY, isDark ? '1' : '-1');
+}
+function resolveInitialColorModeState() {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    return resolvePreferredColorMode() ? 'dark' : 'light';
+}
+/** Runs before paint to avoid light-mode flash on first visit. */
+function buildColorModeInitScript(options = {}) {
+    const storageKey = options.storageKey ?? exports.COLOR_MODE_STORAGE_KEY;
+    const className = options.className ?? 'dark';
+    return `(function(){try{var k='${storageKey}';var s=localStorage.getItem(k);var d=s==='1'||(s==null&&window.matchMedia('(prefers-color-scheme: dark)').matches);if(d){document.documentElement.style.colorScheme='dark';document.body.classList.add('${className}');}else{document.documentElement.style.colorScheme='light';}}catch(e){}})();`;
+}
+exports.colorModeInitScript = buildColorModeInitScript();

package/toolkit/dist/theme/commentAuthor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMENT_EMAIL_REGEXP = exports.COMMENT_AUTHOR_STORAGE_KEY = void 0;
+exports.isValidCommentEmail = isValidCommentEmail;
+exports.isValidCommentAuthor = isValidCommentAuthor;
+exports.getCommentEmailError = getCommentEmailError;
+exports.readCommentAuthor = readCommentAuthor;
+exports.persistCommentAuthor = persistCommentAuthor;
+exports.COMMENT_AUTHOR_STORAGE_KEY = 'reactpress-comment-author';
+/** Permissive enough for common guest comment emails (qq/163/gmail, subdomains). */
+exports.COMMENT_EMAIL_REGEXP = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidCommentEmail(email) {
+    return Boolean(email?.trim() && exports.COMMENT_EMAIL_REGEXP.test(email.trim()));
+}
+function isValidCommentAuthor(author) {
+    return Boolean(author?.name?.trim() && isValidCommentEmail(author.email));
+}
+function getCommentEmailError(email, messages, options = {}) {
+    const trimmed = email?.trim() ?? '';
+    if (!options.touched)
+        return '';
+    if (!trimmed)
+        return messages.required;
+    if (!isValidCommentEmail(trimmed))
+        return messages.invalid;
+    return '';
+}
+function readCommentAuthor() {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const raw = window.localStorage.getItem(exports.COMMENT_AUTHOR_STORAGE_KEY);
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        if (!isValidCommentAuthor(parsed))
+            return null;
+        return { name: parsed.name.trim(), email: parsed.email.trim() };
+    }
+    catch {
+        return null;
+    }
+}
+function persistCommentAuthor(author) {
+    if (typeof window === 'undefined')
+        return;
+    window.localStorage.setItem(exports.COMMENT_AUTHOR_STORAGE_KEY, JSON.stringify({ name: author.name.trim(), email: author.email.trim() }));
+}

package/toolkit/dist/theme/content/archiveSlim.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slimArchiveTree = slimArchiveTree;
+exports.countArchiveArticles = countArchiveArticles;
+exports.formatArchiveDay = formatArchiveDay;
+exports.sortedArchiveYears = sortedArchiveYears;
+function slimArchiveTree(raw) {
+    const out = {};
+    for (const year of Object.keys(raw)) {
+        out[year] = {};
+        for (const month of Object.keys(raw[year])) {
+            out[year][month] = raw[year][month].map(({ id, title, publishAt }) => ({
+                id,
+                title,
+                publishAt,
+            }));
+        }
+    }
+    return out;
+}
+function countArchiveArticles(articles) {
+    let total = 0;
+    for (const year of Object.keys(articles)) {
+        for (const month of Object.keys(articles[year])) {
+            total += articles[year][month].length;
+        }
+    }
+    return total;
+}
+function formatArchiveDay(publishAt) {
+    const date = new Date(publishAt);
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${month}-${day}`;
+}
+function sortedArchiveYears(articles) {
+    return Object.keys(articles).sort((a, b) => +b - +a);
+}

package/toolkit/dist/theme/content/articleSlim.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slimArticleForList = slimArticleForList;
+exports.slimArticlesForList = slimArticlesForList;
+exports.slimArticleForCarousel = slimArticleForCarousel;
+exports.slimArticlesForCarousel = slimArticlesForCarousel;
+function slimArticleForList(article) {
+    return {
+        id: article.id,
+        title: article.title,
+        cover: article.cover,
+        summary: article.summary,
+        likes: article.likes,
+        views: article.views,
+        publishAt: article.publishAt,
+        category: article.category
+            ? { value: article.category.value, label: article.category.label }
+            : undefined,
+    };
+}
+function slimArticlesForList(articles) {
+    return articles.map(slimArticleForList);
+}
+function slimArticleForCarousel(article) {
+    return {
+        id: article.id,
+        title: article.title,
+        cover: article.cover,
+        publishAt: article.publishAt,
+        views: article.views,
+    };
+}
+function slimArticlesForCarousel(articles) {
+    return articles.map(slimArticleForCarousel);
+}

package/toolkit/dist/theme/content/assets.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLikelyValidAssetPath = isLikelyValidAssetPath;
+exports.isLikelyValidHeaderLogoPath = isLikelyValidHeaderLogoPath;
+exports.resolvePublicAssetUrl = resolvePublicAssetUrl;
+exports.rewriteArticleHtmlAssets = rewriteArticleHtmlAssets;
+/** Legacy root paths that live under API `/public` on the server. */
+const PUBLIC_PATH_ALIASES = {
+    '/logo.png': '/public/logo.png',
+    '/favicon.png': '/public/favicon.png',
+    '/favicon.ico': '/public/favicon.ico',
+};
+/** Theme Next rewrites serve alias keys (e.g. `/logo.png`), not `/public/*` API paths. */
+const THEME_LOCAL_PUBLIC_PATHS = Object.fromEntries(Object.entries(PUBLIC_PATH_ALIASES).map(([themePath, apiPath]) => [apiPath, themePath]));
+function normalizePublicAssetPath(path) {
+    return PUBLIC_PATH_ALIASES[path] ?? path;
+}
+function toThemeServablePath(apiPath) {
+    return THEME_LOCAL_PUBLIC_PATHS[apiPath] ?? apiPath;
+}
+/** Paths proxied by theme `next.config` rewrites — keep relative, never bake absolute API URLs. */
+function isThemeRewritePath(path) {
+    return path in THEME_LOCAL_PUBLIC_PATHS || path.startsWith('/public/') || path.startsWith('/uploads/');
+}
+/** Whether a configured asset path is likely to resolve (skip broken defaults like `/logo.png`). */
+function isLikelyValidAssetPath(url) {
+    const trimmed = (url ?? '').trim();
+    if (!trimmed)
+        return false;
+    if (/^https?:\/\//i.test(trimmed) || trimmed.startsWith('/api/') || trimmed.startsWith('/uploads/')) {
+        return true;
+    }
+    if (trimmed.startsWith('/public/') && !PUBLIC_PATH_ALIASES[trimmed.replace('/public', '')]) {
+        return true;
+    }
+    return false;
+}
+/** Header logo — uploads only; default wordmark `/logo.png` is shown via `SiteBranding` text instead. */
+function isLikelyValidHeaderLogoPath(url) {
+    return isLikelyValidAssetPath(url);
+}
+/** Stable public site origin for asset URLs — matches on SSR and client when `NEXT_PUBLIC_*` is set. */
+function resolvePublicSiteOrigin() {
+    const publicApi = (typeof process !== 'undefined' && process.env.NEXT_PUBLIC_REACTPRESS_API_URL?.trim()) || '';
+    if (publicApi) {
+        return publicApi.replace(/\/api\/?$/, '').replace(/\/$/, '');
+    }
+    if (typeof window !== 'undefined') {
+        return window.location.origin;
+    }
+    const serverApi = process.env.REACTPRESS_API_URL?.trim() ||
+        process.env.SERVER_API_URL?.trim() ||
+        'http://localhost:3002/api';
+    return serverApi.replace(/\/api\/?$/, '').replace(/\/$/, '');
+}
+/** Visitor site origin — differs from API origin during SSR (theme :3001 vs API :3002). */
+function resolveThemeSiteOrigin() {
+    if (typeof window !== 'undefined') {
+        return window.location.origin;
+    }
+    const clientSite = process.env.CLIENT_SITE_URL?.trim();
+    if (clientSite) {
+        try {
+            return new URL(clientSite).origin;
+        }
+        catch {
+            return clientSite.replace(/\/$/, '');
+        }
+    }
+    const clientPort = process.env.CLIENT_PORT?.trim() || process.env.PORT?.trim();
+    if (clientPort) {
+        return `http://127.0.0.1:${clientPort}`;
+    }
+    return resolvePublicSiteOrigin();
+}
+/** Resolve media / logo URLs for theme pages. */
+function resolvePublicAssetUrl(url) {
+    const trimmed = (url ?? '').trim();
+    if (!trimmed)
+        return '';
+    if (/^https?:\/\//i.test(trimmed) || trimmed.startsWith('data:'))
+        return trimmed;
+    if (trimmed.startsWith('//')) {
+        const protocol = typeof window !== 'undefined' ? window.location.protocol : 'http:';
+        return `${protocol}${trimmed}`;
+    }
+    if (trimmed.startsWith('/')) {
+        const normalized = normalizePublicAssetPath(trimmed);
+        if (isThemeRewritePath(normalized)) {
+            return toThemeServablePath(normalized);
+        }
+        const origin = resolvePublicSiteOrigin();
+        const themeOrigin = resolveThemeSiteOrigin();
+        if (origin === themeOrigin) {
+            return normalized;
+        }
+        return `${origin}${normalized}`;
+    }
+    return trimmed;
+}
+/** Rewrite relative asset URLs inside rendered article HTML (`src`, `href`). */
+function rewriteArticleHtmlAssets(html) {
+    if (!html?.trim())
+        return html ?? '';
+    return html.replace(/(\b(?:src|href)\s*=\s*)(["'])([^"']+)\2/gi, (_, prefix, quote, url) => `${prefix}${quote}${resolvePublicAssetUrl(url)}${quote}`);
+}

package/toolkit/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/toolkit/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/toolkit/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/toolkit/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/toolkit/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 };