@fecommunity/reactpress-toolkit 3.0.4 → 3.7.0

package/dist/theme/fetch.d.ts

@@ -0,0 +1,134 @@
+import type { ThemeApi } from './api';
+import type { ParseSiteLocaleOptions } from './locale';
+import type { ThemeRuntime } from './runtime';
+import type { SiteMeta } from './setting';
+/** Default ISR interval for theme list/home pages. */
+export declare const THEME_ISR_REVALIDATE_SECONDS = 60;
+/** Retry SSR API calls while the dev server is still starting (ECONNREFUSED). */
+export declare function withApiRetry<T>(fn: () => Promise<T>, attempts?: number, delayMs?: number): Promise<T>;
+/** Articles, categories, and tags for home / toolkit demo pages. */
+export declare function fetchThemeCatalog(api: ThemeApi): Promise<{
+    articles: unknown[];
+    categories: unknown[];
+    tags: unknown[];
+}>;
+/** Strip `undefined` values so Next.js can serialize `getStaticProps` results. */
+export declare function sanitizeNextProps<T>(props: T): T;
+export declare function themeStaticProps<T extends Record<string, unknown>>(props: T, revalidate?: number): {
+    props: T;
+    revalidate: number;
+};
+/** Visitor context for `getStaticProps` — `_app.getInitialProps` does not run on SSR for static pages. */
+export declare function resolveStaticVisitorContext(): Promise<VisitorContextProps>;
+/** All categories — `getStaticProps` for `pages/category/index.tsx`. */
+export declare function fetchCategoryIndex(api: ThemeApi): Promise<{
+    categories: unknown[];
+}>;
+/** All tags — `getStaticProps` for `pages/tag/index.tsx`. */
+export declare function fetchTagIndex(api: ThemeApi): Promise<{
+    tags: unknown[];
+}>;
+/** Site settings for about/footer pages (`getStaticProps`). */
+export declare function fetchSiteSettings<T extends Record<string, {
+    key: string;
+    default: string;
+}>>(api: ThemeApi, schema: T): Promise<{
+    [K in keyof T]: string;
+}>;
+export interface FetchVisitorContextOptions extends ParseSiteLocaleOptions {
+    themeId: string;
+    honorPreview?: boolean;
+}
+/** Props for `ReactPressProvider` — fetch once in `_app.getInitialProps` or `getStaticProps`. */
+export interface VisitorContextProps {
+    locale: string;
+    locales: string[];
+    messages: Record<string, string>;
+    catalog: Record<string, Record<string, string>>;
+    themeId: string;
+    activeThemeId: string;
+    mods: ThemeRuntime['mods'];
+    isPreview: boolean;
+    /** Site settings (`systemTitle`, `systemSubTitle`, …) for branding fallbacks. */
+    siteMeta: SiteMeta;
+}
+/** Safe defaults when API is unreachable (still wraps pages in Provider). */
+export declare function createDefaultVisitorContext(themeId: string, partial?: Partial<VisitorContextProps>): VisitorContextProps;
+export declare function fetchVisitorContext(api: ThemeApi, options: FetchVisitorContextOptions): Promise<VisitorContextProps>;
+/** Common site meta from the Setting row (`systemTitle`, `systemSubTitle`, …). */
+export declare function fetchSiteMeta(api: ThemeApi): Promise<SiteMeta>;
+/** Category archive — `getStaticProps` for `pages/category/[category].tsx`. */
+export declare function fetchCategoryArchive(api: ThemeApi, category: string): Promise<{
+    category: string;
+    articles: unknown[];
+    categories: unknown[];
+}>;
+/** Tag archive — `getStaticProps` for `pages/tag/[tag].tsx`. */
+export declare function fetchTagArchive(api: ThemeApi, tag: string): Promise<{
+    tag: string;
+    articles: unknown[];
+    tags: unknown[];
+}>;
+/** Article shape returned by theme article detail pages. */
+export type ThemeArticlePage = {
+    id: string;
+    title: string;
+    summary?: string;
+    html?: string;
+    cover?: string;
+    publishAt?: string;
+    views?: number;
+    category?: {
+        label: string;
+        value: string;
+    };
+    tags?: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+/** Single article — `getStaticProps` for `pages/article/[id].tsx`. */
+export declare function fetchSingleArticle(api: ThemeApi, id: string): Promise<{
+    article: ThemeArticlePage | null;
+}>;
+/** Site search — `getServerSideProps` / `getStaticProps` helper. */
+export declare function fetchSearchArticles(api: ThemeApi, keyword: string): Promise<{
+    query: string;
+    articles: Array<{
+        id: string;
+        title: string;
+        summary?: string;
+        publishAt?: string;
+        category?: {
+            label: string;
+            value: string;
+        };
+    }>;
+}>;
+export type ThemeArchiveKind = 'category' | 'tag';
+type StaticPropsContext = {
+    params?: Record<string, string | string[] | undefined>;
+};
+/**
+ * Wrap `getStaticProps` fetchers with consistent logging and ISR fallback props.
+ */
+export declare function withThemeStaticProps<T extends Record<string, unknown>>(label: string, fetchFn: () => Promise<T>, fallback: T | ((error: unknown) => T)): Promise<{
+    props: T & {
+        reactPress: VisitorContextProps;
+    };
+    revalidate: number;
+}>;
+/** Factory for category/tag archive pages — removes duplicated `getStaticProps` boilerplate. */
+export declare function createArchiveGetStaticProps<T extends Record<string, unknown>>(kind: ThemeArchiveKind, fetchArchive: (api: ThemeApi, slug: string) => Promise<T>, emptyFallback: (slug: string) => T): (ctx: StaticPropsContext) => Promise<{
+    notFound: true;
+} | {
+    props: T & {
+        reactPress: VisitorContextProps;
+    };
+    revalidate: number;
+}>;
+/** Standard on-demand article page props. */
+export declare function fetchArticlePageProps(api: ThemeApi, id: string | undefined): Promise<{
+    article: ThemeArticlePage | null;
+}>;
+export {};

package/dist/theme/fetch.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THEME_ISR_REVALIDATE_SECONDS = void 0;
+exports.withApiRetry = withApiRetry;
+exports.fetchThemeCatalog = fetchThemeCatalog;
+exports.sanitizeNextProps = sanitizeNextProps;
+exports.themeStaticProps = themeStaticProps;
+exports.resolveStaticVisitorContext = resolveStaticVisitorContext;
+exports.fetchCategoryIndex = fetchCategoryIndex;
+exports.fetchTagIndex = fetchTagIndex;
+exports.fetchSiteSettings = fetchSiteSettings;
+exports.createDefaultVisitorContext = createDefaultVisitorContext;
+exports.fetchVisitorContext = fetchVisitorContext;
+exports.fetchSiteMeta = fetchSiteMeta;
+exports.fetchCategoryArchive = fetchCategoryArchive;
+exports.fetchTagArchive = fetchTagArchive;
+exports.fetchSingleArticle = fetchSingleArticle;
+exports.fetchSearchArticles = fetchSearchArticles;
+exports.withThemeStaticProps = withThemeStaticProps;
+exports.createArchiveGetStaticProps = createArchiveGetStaticProps;
+exports.fetchArticlePageProps = fetchArticlePageProps;
+const api_1 = require("./api");
+const api_data_1 = require("./api-data");
+const format_1 = require("./format");
+const json_1 = require("./json");
+const locale_1 = require("./locale");
+const runtime_1 = require("./runtime");
+const setting_1 = require("./setting");
+const static_1 = require("./static");
+/** Default ISR interval for theme list/home pages. */
+exports.THEME_ISR_REVALIDATE_SECONDS = 60;
+function isConnectionRefused(error) {
+    const err = error;
+    return err?.code === 'ECONNREFUSED' || err?.cause?.code === 'ECONNREFUSED';
+}
+/** Retry SSR API calls while the dev server is still starting (ECONNREFUSED). */
+async function withApiRetry(fn, attempts = 8, delayMs = 400) {
+    let lastError;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isConnectionRefused(error) || i >= attempts - 1) {
+                throw error;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, delayMs);
+            });
+        }
+    }
+    throw lastError;
+}
+/** Articles, categories, and tags for home / toolkit demo pages. */
+async function fetchThemeCatalog(api) {
+    return withApiRetry(async () => {
+        const [articlesResponse, categoriesResponse, tagsResponse] = await Promise.all([
+            api.article.findAll(),
+            api.category.findAll(),
+            api.tag.findAll(),
+        ]);
+        return {
+            articles: (0, api_data_1.unpackPaginated)(articlesResponse),
+            categories: (0, api_data_1.unpackList)(categoriesResponse),
+            tags: (0, api_data_1.unpackList)(tagsResponse),
+        };
+    });
+}
+/** Strip `undefined` values so Next.js can serialize `getStaticProps` results. */
+function sanitizeNextProps(props) {
+    return JSON.parse(JSON.stringify(props));
+}
+function themeStaticProps(props, revalidate = exports.THEME_ISR_REVALIDATE_SECONDS) {
+    return { props: sanitizeNextProps(props), revalidate };
+}
+let staticVisitorContextPromise = null;
+let staticVisitorContextKey = '';
+/** Visitor context for `getStaticProps` — `_app.getInitialProps` does not run on SSR for static pages. */
+async function resolveStaticVisitorContext() {
+    const themeId = process.env.REACTPRESS_THEME_ID?.trim() || 'starter-theme';
+    const honorPreview = process.env.REACTPRESS_HONOR_PREVIEW === '1';
+    const cacheKey = `${themeId}:${honorPreview ? '1' : '0'}`;
+    if (staticVisitorContextPromise && staticVisitorContextKey === cacheKey) {
+        return staticVisitorContextPromise;
+    }
+    staticVisitorContextKey = cacheKey;
+    staticVisitorContextPromise = (async () => {
+        try {
+            return await fetchVisitorContext(api_1.themeApi, { themeId, honorPreview });
+        }
+        catch (error) {
+            const code = error?.code
+                ?? error?.cause?.code;
+            if (code !== 'ECONNREFUSED') {
+                console.error('[reactpress] resolveStaticVisitorContext failed', error);
+            }
+            return createDefaultVisitorContext(themeId);
+        }
+    })();
+    return staticVisitorContextPromise;
+}
+/** All categories — `getStaticProps` for `pages/category/index.tsx`. */
+async function fetchCategoryIndex(api) {
+    return { categories: (0, api_data_1.unpackList)(await api.category.findAll()) };
+}
+/** All tags — `getStaticProps` for `pages/tag/index.tsx`. */
+async function fetchTagIndex(api) {
+    return { tags: (0, api_data_1.unpackList)(await api.tag.findAll()) };
+}
+/** Site settings for about/footer pages (`getStaticProps`). */
+async function fetchSiteSettings(api, schema) {
+    const rows = (0, api_data_1.unpackList)(await api.setting.findAll());
+    return (0, format_1.pickSiteSettings)(rows, schema);
+}
+/** Safe defaults when API is unreachable (still wraps pages in Provider). */
+function createDefaultVisitorContext(themeId, partial = {}) {
+    return {
+        locale: 'zh',
+        locales: ['zh', 'en'],
+        messages: {},
+        catalog: {},
+        themeId,
+        activeThemeId: themeId,
+        mods: {},
+        isPreview: false,
+        siteMeta: setting_1.DEFAULT_SITE_META,
+        ...partial,
+    };
+}
+async function fetchVisitorContext(api, options) {
+    if (!api?.setting?.findAll) {
+        throw new Error('fetchVisitorContext: invalid ThemeApi instance');
+    }
+    return withApiRetry(async () => {
+        const row = (0, setting_1.unwrapSetting)(await api.setting.findAll());
+        const localeState = (0, locale_1.parseSiteLocale)(row?.i18n, {
+            locale: options.locale,
+            fallbackLocale: options.fallbackLocale,
+            preferredLocale: options.preferredLocale,
+            acceptLanguage: options.acceptLanguage,
+        });
+        const globalSetting = (0, json_1.safeJsonParse)(row?.globalSetting, {});
+        const runtime = (0, runtime_1.resolveThemeRuntime)(globalSetting, {
+            themeId: options.themeId,
+            honorPreview: options.honorPreview,
+        });
+        const siteMeta = (0, setting_1.parseSiteMeta)(row);
+        return {
+            locale: localeState.locale,
+            locales: localeState.locales,
+            messages: localeState.messages,
+            catalog: localeState.catalog,
+            themeId: runtime.themeId,
+            activeThemeId: runtime.activeThemeId,
+            mods: runtime.mods,
+            isPreview: runtime.isPreview,
+            siteMeta,
+        };
+    });
+}
+/** Common site meta from the Setting row (`systemTitle`, `systemSubTitle`, …). */
+async function fetchSiteMeta(api) {
+    return withApiRetry(async () => {
+        const row = (0, setting_1.unwrapSetting)(await api.setting.findAll());
+        return (0, setting_1.parseSiteMeta)(row);
+    });
+}
+/** Category archive — `getStaticProps` for `pages/category/[category].tsx`. */
+async function fetchCategoryArchive(api, category) {
+    const [articlesResponse, categoriesResponse] = await Promise.all([
+        api.article.findArticlesByCategory(category),
+        api.category.findAll(),
+    ]);
+    return {
+        category,
+        articles: (0, api_data_1.unpackPaginated)(articlesResponse),
+        categories: (0, api_data_1.unpackList)(categoriesResponse),
+    };
+}
+/** Tag archive — `getStaticProps` for `pages/tag/[tag].tsx`. */
+async function fetchTagArchive(api, tag) {
+    const [articlesResponse, tagsResponse] = await Promise.all([
+        api.article.findArticlesByTag(tag),
+        api.tag.findAll(),
+    ]);
+    return {
+        tag,
+        articles: (0, api_data_1.unpackPaginated)(articlesResponse),
+        tags: (0, api_data_1.unpackList)(tagsResponse),
+    };
+}
+/** Single article — `getStaticProps` for `pages/article/[id].tsx`. */
+async function fetchSingleArticle(api, id) {
+    const articleResponse = await api.article.findById(id);
+    return { article: (0, api_data_1.unpackOne)(articleResponse) };
+}
+/** Site search — `getServerSideProps` / `getStaticProps` helper. */
+async function fetchSearchArticles(api, keyword) {
+    if (!keyword.trim()) {
+        return { query: '', articles: [] };
+    }
+    const searchResponse = await api.search.searchArticle({
+        query: { keyword: keyword.trim() },
+    });
+    return {
+        query: keyword.trim(),
+        articles: (0, api_data_1.unpackList)(searchResponse),
+    };
+}
+/**
+ * Wrap `getStaticProps` fetchers with consistent logging and ISR fallback props.
+ */
+async function withThemeStaticProps(label, fetchFn, fallback) {
+    const reactPress = await resolveStaticVisitorContext();
+    try {
+        const data = await withApiRetry(fetchFn);
+        return themeStaticProps({ ...data, reactPress });
+    }
+    catch (error) {
+        console.error(`[reactpress] ${label}`, error);
+        const props = typeof fallback === 'function' ? fallback(error) : fallback;
+        return themeStaticProps({ ...props, reactPress });
+    }
+}
+/** Factory for category/tag archive pages — removes duplicated `getStaticProps` boilerplate. */
+function createArchiveGetStaticProps(kind, fetchArchive, emptyFallback) {
+    return async (ctx) => {
+        const slug = ctx.params?.[kind];
+        if (typeof slug !== 'string' || !slug)
+            return (0, static_1.themeNotFound)();
+        return withThemeStaticProps(`fetch ${kind} archive failed`, () => fetchArchive(api_1.themeApi, slug), () => emptyFallback(slug));
+    };
+}
+/** Standard on-demand article page props. */
+async function fetchArticlePageProps(api, id) {
+    if (!id)
+        return { article: null };
+    const data = await fetchSingleArticle(api, id);
+    return { article: data.article ?? null };
+}

package/dist/theme/format.d.ts

@@ -0,0 +1,16 @@
+/** Format article `publishAt` for theme templates (SSR-safe). */
+export declare function formatPublishDate(value: string | Date | null | undefined, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+/** Short numeric date (`YYYY-MM-DD`) via toolkit utils. */
+export declare function formatPublishDateShort(value: string | Date | null | undefined): string;
+export type SettingRow = {
+    key: string;
+    value?: unknown;
+    [field: string]: unknown;
+};
+/** Map global settings rows to a props object by key. */
+export declare function pickSiteSettings<T extends Record<string, {
+    key: string;
+    default: string;
+}>>(settings: SettingRow[], schema: T): {
+    [K in keyof T]: string;
+};

package/dist/theme/format.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPublishDate = formatPublishDate;
+exports.formatPublishDateShort = formatPublishDateShort;
+exports.pickSiteSettings = pickSiteSettings;
+const utils_1 = require("../utils");
+/** Format article `publishAt` for theme templates (SSR-safe). */
+function formatPublishDate(value, options = {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+}, locale = 'en-US') {
+    if (value == null || value === '')
+        return '';
+    try {
+        const date = value instanceof Date ? value : new Date(value);
+        if (Number.isNaN(date.getTime()))
+            return '';
+        return date.toLocaleDateString(locale, options);
+    }
+    catch {
+        return '';
+    }
+}
+/** Short numeric date (`YYYY-MM-DD`) via toolkit utils. */
+function formatPublishDateShort(value) {
+    if (value == null || value === '')
+        return '';
+    try {
+        const date = value instanceof Date ? value : new Date(value);
+        if (Number.isNaN(date.getTime()))
+            return '';
+        return (0, utils_1.formatDate)(date, 'YYYY-MM-DD');
+    }
+    catch {
+        return '';
+    }
+}
+/** Map global settings rows to a props object by key. */
+function pickSiteSettings(settings, schema) {
+    const out = {};
+    for (const prop of Object.keys(schema)) {
+        const { key, default: fallback } = schema[prop];
+        const row = settings.find((s) => s.key === key);
+        out[prop] = row?.value != null ? String(row.value) : fallback;
+    }
+    return out;
+}

package/dist/theme/httpClient.d.ts

@@ -0,0 +1,20 @@
+import { type AxiosInstance } from 'axios';
+export interface ThemeApiEnvelope<T = unknown> {
+    statusCode: number;
+    success: boolean;
+    msg: string | null;
+    data: T;
+}
+export interface CreateThemeAxiosClientOptions {
+    baseURL?: string;
+    timeout?: number;
+    getAccessToken?: () => string | null;
+    onError?: (message: string, status?: number) => void;
+    onUnauthorized?: () => void;
+    unwrapEnvelope?: boolean;
+}
+/** Legacy theme env vars plus toolkit defaults. */
+export declare function resolveThemeAxiosBaseUrl(): string;
+/** Encode dynamic path segments (e.g. Chinese tag names) for Node fetch / axios. */
+export declare function encodeAxiosUrlPath(url: string): string;
+export declare function createThemeAxiosClient(options?: CreateThemeAxiosClientOptions): AxiosInstance;

package/dist/theme/httpClient.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveThemeAxiosBaseUrl = resolveThemeAxiosBaseUrl;
+exports.encodeAxiosUrlPath = encodeAxiosUrlPath;
+exports.createThemeAxiosClient = createThemeAxiosClient;
+const axios_1 = __importDefault(require("axios"));
+const authSession_1 = require("./authSession");
+const api_1 = require("./api");
+/** Legacy theme env vars plus toolkit defaults. */
+function resolveThemeAxiosBaseUrl() {
+    if (process.env.SERVER_API_URL) {
+        return process.env.SERVER_API_URL;
+    }
+    if (process.env.SERVER_SITE_URL) {
+        return `${process.env.SERVER_SITE_URL}/api`;
+    }
+    return (0, api_1.resolveThemeApiBaseUrl)();
+}
+/** Encode dynamic path segments (e.g. Chinese tag names) for Node fetch / axios. */
+function encodeAxiosUrlPath(url) {
+    const qIndex = url.indexOf('?');
+    const pathname = qIndex === -1 ? url : url.slice(0, qIndex);
+    const search = qIndex === -1 ? '' : url.slice(qIndex);
+    const encodedPath = pathname
+        .split('/')
+        .map((segment) => {
+        if (!segment)
+            return segment;
+        try {
+            return encodeURIComponent(decodeURIComponent(segment));
+        }
+        catch {
+            return encodeURIComponent(segment);
+        }
+    })
+        .join('/');
+    return encodedPath + search;
+}
+function createThemeAxiosClient(options = {}) {
+    const isBrowser = typeof window !== 'undefined';
+    const { baseURL = resolveThemeAxiosBaseUrl(), timeout = 60000, getAccessToken = authSession_1.getStoredAccessToken, onError, onUnauthorized, unwrapEnvelope = true, } = options;
+    const client = axios_1.default.create({ baseURL, timeout });
+    client.interceptors.request.use((config) => {
+        if (config.url) {
+            config.url = encodeAxiosUrlPath(config.url);
+        }
+        if (isBrowser) {
+            const token = getAccessToken();
+            if (config.headers && token) {
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+        }
+        return config;
+    }, () => {
+        throw new Error('Failed to send request');
+    });
+    client.interceptors.response.use((response) => {
+        if (!unwrapEnvelope) {
+            return response;
+        }
+        const payload = response.data;
+        if (!payload?.success) {
+            onError?.(payload?.msg || 'Request failed');
+            return Promise.reject({
+                statusCode: payload?.statusCode,
+                message: payload?.msg,
+            });
+        }
+        return payload.data;
+    }, (err) => {
+        const status = err?.response?.status;
+        const msg = err?.response?.data?.msg;
+        if (status === 401) {
+            onUnauthorized?.();
+            onError?.(msg || 'Unauthorized');
+        }
+        else if (status) {
+            onError?.(msg || 'Server error', status);
+        }
+        return Promise.reject({
+            statusCode: status,
+            message: msg,
+        });
+    });
+    return client;
+}

package/dist/theme/index.d.ts

@@ -0,0 +1,63 @@
+export type { ThemeApi } from './api/api';
+export { createThemeApi, getThemeApiBaseUrl, resolveThemeApiBaseUrl, themeApi, } from './api/api';
+export type { ApiEnvelope } from '../utils/api-envelope';
+export { unpackList, unpackOne, unpackPaginated, unpackPaginatedPair, } from '../utils/api-envelope';
+export { isLikelyValidAssetPath, isLikelyValidHeaderLogoPath, resolvePublicAssetUrl, rewriteArticleHtmlAssets } from './content/assets';
+export type { ArchiveExcerptMode, ResolveArchiveExcerptOptions } from './content/excerpt';
+export { resolveArchiveExcerpt, stripHtml, truncateWords, } from './content/excerpt';
+export type { AppBootstrapResult, FetchAppBootstrapOptions } from './ssr/bootstrap';
+export { createDefaultAppBootstrap, fetchAppBootstrap, fetchArchives, fetchCmsPage, fetchKnowledgeDetail, fetchKnowledgeList, fetchPublishedPages, fetchRecommendArticles, } from './ssr/bootstrap';
+export type { SlimBootstrapOptions } from './ssr/slimBootstrap';
+export { createBootstrapSlimmer, slimAppBootstrapForRoute, } from './ssr/slimBootstrap';
+export type { CarouselArticle, ListArticle, } from './content/articleSlim';
+export { slimArticleForCarousel, slimArticleForList, slimArticlesForCarousel, slimArticlesForList, } from './content/articleSlim';
+export type { ArchiveArticle, ArchiveTree } from './content/archiveSlim';
+export { countArchiveArticles, formatArchiveDay, slimArchiveTree, sortedArchiveYears, } from './content/archiveSlim';
+export type { ResolveCarouselArticlesOptions } from './content/carouselArticles';
+export { resolveCarouselArticles } from './content/carouselArticles';
+export type { CategoryArchivePageProps, HomePageProps, KnowledgeIndexPageProps, SearchPageProps, TagArchivePageProps, } from './ssr/pageProps';
+export { fetchArchivesPageProps, fetchArticleDetailProps, fetchCategoryArchivePageProps, fetchCmsPageProps, fetchHomePageProps, fetchKnowledgeBookPageProps, fetchKnowledgeChapterPageProps, fetchKnowledgeIndexPageProps, fetchSearchPageProps, fetchTagArchivePageProps, } from './ssr/pageProps';
+export type { FetchVisitorContextOptions, ThemeArchiveKind, VisitorContextProps } from './ssr/fetch';
+export { createArchiveGetStaticProps, createDefaultVisitorContext, fetchArticlePageProps, fetchCategoryArchive, fetchCategoryIndex, fetchSearchArticles, fetchSingleArticle, fetchSiteMeta, fetchSiteSettings, fetchTagArchive, fetchTagIndex, fetchThemeCatalog, fetchVisitorContext, resolveStaticVisitorContext, sanitizeNextProps, THEME_ISR_REVALIDATE_SECONDS, themeStaticProps, withApiRetry, withThemeStaticProps, } from './ssr/fetch';
+export type { SettingRow } from '../utils/setting';
+export { formatPublishDate, formatPublishDateShort, } from '../utils/date';
+export { pickSiteSettings } from '../utils/setting';
+export { safeJsonParse } from '../utils/json';
+export type { ImageVariant } from '../utils/image';
+export { resolveImageUrl } from '../utils/image';
+export type { ThemeSessionUser, } from './visitor/authSession';
+export { ADMIN_AUTH_STORAGE_KEY, clearThemeSession, getStoredAccessToken, persistThemeSession, resolveStoredUser, THEME_TOKEN_STORAGE_KEY, THEME_USER_STORAGE_KEY, } from './visitor/authSession';
+export type { ThemeColorMode } from './visitor/colorMode';
+export { applyColorModeClass, buildColorModeInitScript, COLOR_MODE_STORAGE_KEY, colorModeInitScript, persistColorMode, resolveClientThemeMode, resolveInitialColorModeState, resolvePreferredColorMode, } from './visitor/colorMode';
+export { DEFAULT_VISITOR_LOCALES, LEGACY_LOCALE_STORAGE_KEY, persistVisitorLocale, readBrowserCookie, readRequestCookie, resolveVisitorLocale, VISITOR_LOCALE_COOKIE, } from './visitor/visitorLocale';
+export type { CommentAuthor } from './visitor/commentAuthor';
+export { COMMENT_AUTHOR_STORAGE_KEY, COMMENT_EMAIL_REGEXP, getCommentEmailError, isValidCommentAuthor, isValidCommentEmail, persistCommentAuthor, readCommentAuthor, } from './visitor/commentAuthor';
+export type { SiteTitleSource } from './content/seo';
+export { getPageTitle, getSiteTitle } from './content/seo';
+export { jsonp } from '../utils/jsonp';
+export type { CreateThemeAxiosClientOptions, ThemeApiEnvelope, } from './api/httpClient';
+export { createThemeAxiosClient, encodeAxiosUrlPath, resolveThemeAxiosBaseUrl, } from './api/httpClient';
+export type { LocaleCatalog, LocaleMessages, ParseSiteLocaleOptions, SiteLocaleState, } from './visitor/locale';
+export { createTranslator, parseSiteLocale, resolveRequestLocale, } from './visitor/locale';
+export { mergeVisitorI18n, slimVisitorI18nForSsr } from './visitor/i18n';
+export type { NavItem } from './content/nav';
+export { articlePath, categoryPath, getNavActiveId, tagPath, } from './content/nav';
+export type { ResolveThemeRuntimeOptions, ThemeRuntime } from './visitor/runtime';
+export { resolveThemeRuntime } from './visitor/runtime';
+export type { SiteMeta } from './ssr/setting';
+export { DEFAULT_SITE_META, parseSiteMeta, unwrapSetting } from './ssr/setting';
+export { createThemeProviders } from './providers';
+export type { ThemeProviders } from './providers';
+export type { CreateThemeHttpStackOptions } from './providers/setup';
+export { createThemeHttpStack } from './providers/setup';
+export { defaultModsFromManifest } from './visitor/appearance';
+export type ThemeManifestRef = {
+    id: string;
+};
+export * from './extension';
+export { themeNotFound, themeOnDemandPaths, themeStaticNotFound } from './ssr/static';
+export type { ThemeManifestLike, ThemeTemplateSlug } from './ssr/templates';
+export { DEFAULT_TEMPLATE_FILES, resolveTemplateFiles, ThemeTemplate } from './ssr/templates';
+/** Headless theme UI — also available from `@fecommunity/reactpress-toolkit/ui`. */
+export type { ArchiveEmptyStateProps, ArchivePageLayoutProps, ArticleCardArticle, ArticleCardLinkProps, ArticleCardProps, ArticleListProps, BaseGlobalStylesProps, LocaleContextValue, LocaleProviderProps, LocaleSwitcherProps, NavMenuProps, NavMenuRenderLinkProps, NotFoundPanelProps, PageHeaderProps, ReactPressProviderProps, SiteBrandingProps, SiteDocumentFallbackProps, SiteDocumentProps, SiteLogoProps, SiteTaglineProps, TaxonomyItem, TaxonomyListProps, TaxonomyListRenderLinkProps, TaxonomyListVariant, ThemeLayoutProps, ThemeRuntimeContextValue, ThemeRuntimeProviderProps, SiteCatalogContextValue, SiteCatalogSiteConfig, SiteConfigNav, SiteSeoProps, SiteAnalyticsProps, } from '../ui';
+export { ArchiveEmptyState, ArchivePageLayout, ArticleCard, ArticleList, BaseGlobalStyles, LocaleProvider, LocaleSwitcher, NavMenu, NotFoundPanel, PageHeader, ReactPressProvider, readPersistedLocale, SiteBranding, SiteDocument, SiteDocumentFallback, SiteLogo, SiteTagline, TaxonomyList, ThemeCssVars, ThemeLayout, ThemeRuntimeProvider, useActiveThemeId, useIsThemePreview, useLocale, useAsyncLoading, useForceUpdate, useNavActive, usePagination, useReportArticleView, useReportPageView, useRouteParam, useToggle, useWarningOnExit, useSiteMeta, useThemeId, useThemeMod, useThemeModBool, useThemeRuntime, SiteCatalogContext, SiteCatalogProvider, SiteSeo, SiteAnalytics, useSiteCatalog, useSiteSetting, useSiteUser, useColorMode, useSiteConfig, } from '../ui';