@fecommunity/reactpress-toolkit 3.0.4 → 3.7.0

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 };

package/dist/theme/createCatalogApp.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Full-featured theme `_app` factory (UI-framework agnostic).
+ *
+ * @param {object} manifest — theme.json manifest
+ * @param {object} options
+ * @param {React.ComponentType} options.Layout
+ * @param {React.ComponentType} options.IntlProvider — from the theme's `next-intl` install
+ * @param {(mods: object) => string} [options.buildAppearanceCss]
+ * @param {(content: React.ReactNode, runtime: object) => React.ReactNode} [options.wrapContent]
+ * @param {object} [options.httpClientOptions]
+ * @param {boolean} [options.scrollToTopOnRouteChange=true]
+ */
+export function createCatalogThemeApp(manifest: object, options?: {
+    Layout: React.ComponentType;
+    IntlProvider: React.ComponentType;
+    buildAppearanceCss?: ((mods: object) => string) | undefined;
+    wrapContent?: ((content: React.ReactNode, runtime: object) => React.ReactNode) | undefined;
+    httpClientOptions?: object | undefined;
+    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/createCatalogApp.js

@@ -0,0 +1,168 @@
+"use strict";
+const React = require('react');
+const App = require('next/app').default;
+const Router = require('next/router').default;
+const { fetchAppBootstrap } = require('./ssr/bootstrap');
+const { createThemeAxiosClient } = require('./api/httpClient');
+const { createThemeProviders } = require('./providers');
+const { applyColorModeClass, resolveClientThemeMode, resolveInitialColorModeState, persistVisitorLocale, } = require('./visitor/colorMode');
+const { clearThemeSession, persistThemeSession, resolveStoredUser, } = require('./visitor/authSession');
+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 theme `_app` factory (UI-framework agnostic).
+ *
+ * @param {object} manifest — theme.json manifest
+ * @param {object} options
+ * @param {React.ComponentType} options.Layout
+ * @param {React.ComponentType} options.IntlProvider — from the theme's `next-intl` install
+ * @param {(mods: object) => string} [options.buildAppearanceCss]
+ * @param {(content: React.ReactNode, runtime: object) => React.ReactNode} [options.wrapContent]
+ * @param {object} [options.httpClientOptions]
+ * @param {boolean} [options.scrollToTopOnRouteChange=true]
+ */
+function createCatalogThemeApp(manifest, options = {}) {
+    var _a;
+    const { Layout, buildAppearanceCss, httpClientOptions = {}, scrollToTopOnRouteChange = true, IntlProvider, wrapContent, } = options;
+    if (!Layout) {
+        throw new Error('createCatalogThemeApp: options.Layout is required');
+    }
+    if (!IntlProvider) {
+        throw new Error('createCatalogThemeApp: 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 CatalogThemeApp 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, 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 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,
+            };
+            const layout = React.createElement(Layout, {
+                needHeader: true,
+                needFooter: needLayoutFooter,
+                hasBg,
+            }, React.createElement(RouteProgress, null), React.createElement(Component, pageProps));
+            const runtime = { locale, isDark, colorPrimary, themeMods, colorMode: this.state.theme };
+            const content = wrapContent ? wrapContent(layout, runtime) : layout;
+            return React.createElement(SiteCatalogProvider, { value: catalogValue }, React.createElement(IntlProvider, { messages: message, locale }, appearanceCss
+                ? React.createElement('style', {
+                    dangerouslySetInnerHTML: { __html: appearanceCss },
+                })
+                : null, React.createElement(ViewStatisticsBridge, null), React.createElement(SiteAnalytics, null), content));
+        }
+    }
+    _a = CatalogThemeApp;
+    CatalogThemeApp.getInitialProps = async (appContext) => {
+        const appProps = await App.getInitialProps(appContext);
+        const bootstrap = await fetchAppBootstrap({
+            manifest,
+            ctx: appContext.ctx,
+        });
+        return {
+            ...appProps,
+            ...bootstrap,
+            pageProps: appProps.pageProps,
+        };
+    };
+    return CatalogThemeApp;
+}
+module.exports = { createCatalogThemeApp };

package/dist/theme/customizer.d.ts

@@ -0,0 +1 @@
+export { defaultModsFromManifest } from './appearance';

package/dist/theme/customizer.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultModsFromManifest = void 0;
+var appearance_1 = require("./appearance");
+Object.defineProperty(exports, "defaultModsFromManifest", { enumerable: true, get: function () { return appearance_1.defaultModsFromManifest; } });

package/dist/theme/excerpt.d.ts

@@ -0,0 +1,16 @@
+export type ArchiveExcerptMode = 'excerpt' | 'full' | 'none';
+/** Strip HTML tags and collapse whitespace for archive excerpts. */
+export declare function stripHtml(html: string): string;
+/** Truncate text to a word limit with an ellipsis. */
+export declare function truncateWords(text: string, limit?: number): string;
+export interface ResolveArchiveExcerptOptions {
+    mode?: ArchiveExcerptMode;
+    content?: 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, summary, wordLimit, }: ResolveArchiveExcerptOptions): string | null;

package/dist/theme/excerpt.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripHtml = stripHtml;
+exports.truncateWords = truncateWords;
+exports.resolveArchiveExcerpt = resolveArchiveExcerpt;
+const DEFAULT_EXCERPT_WORD_LIMIT = 55;
+/** Strip HTML tags and collapse whitespace for archive excerpts. */
+function stripHtml(html) {
+    return html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+/** Truncate text to a word limit with an ellipsis. */
+function truncateWords(text, limit = DEFAULT_EXCERPT_WORD_LIMIT) {
+    const words = text.trim().split(/\s+/).filter(Boolean);
+    if (words.length <= limit)
+        return text.trim();
+    return `${words.slice(0, limit).join(' ')}…`;
+}
+/**
+ * Resolve archive list excerpt text from customizer `archiveExcerpt` mode.
+ * Returns `null` when the excerpt should be hidden.
+ */
+function resolveArchiveExcerpt({ mode = 'excerpt', content, summary, wordLimit = DEFAULT_EXCERPT_WORD_LIMIT, }) {
+    if (mode === 'none')
+        return null;
+    const raw = stripHtml(content ?? '') || summary?.trim() || '';
+    if (!raw)
+        return null;
+    if (mode === 'full')
+        return raw;
+    return truncateWords(raw, wordLimit);
+}

package/dist/theme/extension/branding-mods.d.ts

@@ -0,0 +1,10 @@
+export type ThemeMods = Record<string, string>;
+/** Customizer mod id → legacy Setting column (runtime overlay for themes). */
+export declare const THEME_BRANDING_MOD_TO_SETTING: Record<string, string>;
+/** Mod ids stored under the same key in mods and Setting overlay. */
+export declare const THEME_BRANDING_DIRECT_MODS: readonly ["systemFooterInfo", "aboutUsGithubUrl", "aboutUsCommentQr", "aboutUsWechatQr"];
+/** Build customizer form seed from legacy Setting columns (one-time / fallback). */
+export declare function seedThemeModsFromLegacySetting(setting: Record<string, unknown> | null | undefined, mods?: ThemeMods): ThemeMods;
+/** Overlay theme mods onto a Setting-shaped object for theme runtime & mail templates. */
+export declare function applyThemeModsToSiteSetting<T extends Record<string, unknown>>(setting: T, mods: ThemeMods): T;
+export declare function brandingModValue(mods: ThemeMods, modId: string): string | undefined;

package/dist/theme/extension/branding-mods.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THEME_BRANDING_DIRECT_MODS = exports.THEME_BRANDING_MOD_TO_SETTING = void 0;
+exports.seedThemeModsFromLegacySetting = seedThemeModsFromLegacySetting;
+exports.applyThemeModsToSiteSetting = applyThemeModsToSiteSetting;
+exports.brandingModValue = brandingModValue;
+/** Customizer mod id → legacy Setting column (runtime overlay for themes). */
+exports.THEME_BRANDING_MOD_TO_SETTING = {
+    displayTitle: 'systemTitle',
+    displayTagline: 'systemSubTitle',
+    siteLogo: 'systemLogo',
+    backgroundImage: 'systemBg',
+    siteFavicon: 'systemFavicon',
+    siteNotice: 'systemNoticeInfo',
+    seoKeyword: 'seoKeyword',
+    seoDesc: 'seoDesc',
+    baiduAnalyticsId: 'baiduAnalyticsId',
+    googleAnalyticsId: 'googleAnalyticsId',
+};
+/** Mod ids stored under the same key in mods and Setting overlay. */
+exports.THEME_BRANDING_DIRECT_MODS = [
+    'systemFooterInfo',
+    'aboutUsGithubUrl',
+    'aboutUsCommentQr',
+    'aboutUsWechatQr',
+];
+function modValue(mods, modId) {
+    const v = mods[modId];
+    if (v == null || String(v).trim() === '')
+        return undefined;
+    return String(v);
+}
+/** Build customizer form seed from legacy Setting columns (one-time / fallback). */
+function seedThemeModsFromLegacySetting(setting, mods = {}) {
+    const merged = { ...mods };
+    for (const [modId, settingKey] of Object.entries(exports.THEME_BRANDING_MOD_TO_SETTING)) {
+        if (!modValue(merged, modId) && setting?.[settingKey] != null) {
+            merged[modId] = String(setting[settingKey]);
+        }
+    }
+    for (const key of exports.THEME_BRANDING_DIRECT_MODS) {
+        if (!modValue(merged, key) && setting?.[key] != null) {
+            merged[key] = String(setting[key]);
+        }
+    }
+    return merged;
+}
+/** Overlay theme mods onto a Setting-shaped object for theme runtime & mail templates. */
+function applyThemeModsToSiteSetting(setting, mods) {
+    const next = { ...setting };
+    for (const [modId, settingKey] of Object.entries(exports.THEME_BRANDING_MOD_TO_SETTING)) {
+        const v = modValue(mods, modId);
+        if (v)
+            next[settingKey] = v;
+    }
+    for (const key of exports.THEME_BRANDING_DIRECT_MODS) {
+        const v = modValue(mods, key);
+        if (v)
+            next[key] = v;
+    }
+    return next;
+}
+function brandingModValue(mods, modId) {
+    return modValue(mods, modId);
+}

package/dist/theme/extension/configuration/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeConfigurationSchema } from './types';
+/** Collect `default` values from a JSON Schema object tree. */
+export declare function defaultsFromSchema(schema: ThemeConfigurationSchema | null | undefined): Record<string, unknown>;

package/dist/theme/extension/configuration/defaults.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultsFromSchema = defaultsFromSchema;
+/** Collect `default` values from a JSON Schema object tree. */
+function defaultsFromSchema(schema) {
+    if (!schema?.properties)
+        return {};
+    const out = {};
+    for (const [key, prop] of Object.entries(schema.properties)) {
+        const value = defaultFromProperty(prop);
+        if (value !== undefined) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function defaultFromProperty(prop) {
+    if (!prop)
+        return undefined;
+    if (prop.default !== undefined)
+        return prop.default;
+    if (prop.type === 'object' && prop.properties) {
+        const nested = {};
+        for (const [k, p] of Object.entries(prop.properties)) {
+            const v = defaultFromProperty(p);
+            if (v !== undefined)
+                nested[k] = v;
+        }
+        return Object.keys(nested).length ? nested : undefined;
+    }
+    return undefined;
+}

package/dist/theme/extension/configuration/formily.d.ts

@@ -0,0 +1,10 @@
+import type { ThemeConfigurationSchema } from './types';
+/** Formily `ISchema` node (JSON Schema + Formily x-* extensions). */
+export type FormilySchemaNode = Record<string, unknown>;
+export declare function registerFormilyWidget(widgetId: string, componentName: string): void;
+/**
+ * Convert theme `reactpress.configuration` JSON Schema to Formily render schema.
+ * Adds `x-decorator` / `x-component` from types and `x-ui.widget`.
+ */
+export declare function toFormilyJsonSchema(schema: ThemeConfigurationSchema | null | undefined): FormilySchemaNode | null;
+export declare function getFormilyVoidComponents(): string[];