@fecommunity/reactpress-toolkit 3.0.0 → 3.1.0

package/dist/theme/providers/index.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThemeProviders = createThemeProviders;
+/** Create REST provider classes bound to a theme HTTP client (axios + envelope unwrap). */
+function createThemeProviders(http) {
+    class SettingProvider {
+        static async getSetting() {
+            return http.post('/setting/get');
+        }
+        static async updateSetting(data) {
+            return http.post('/setting', data);
+        }
+    }
+    class ArticleProvider {
+        static async getArticles(params) {
+            return http.get('/article', { params });
+        }
+        static async getAllRecommendArticles() {
+            return http.get('/article/all/recommend');
+        }
+        static async getArticlesByCategory(category, params) {
+            return http.get(`/article/category/${category}`, { params });
+        }
+        static async getArticlesByTag(tag, params) {
+            return http.get(`/article/tag/${tag}`, { params });
+        }
+        static async getRecommend(articleId = null, pageSize = 6) {
+            return http.get('/article/recommend', { params: { articleId, pageSize } });
+        }
+        static async getArchives() {
+            return http.get('/article/archives');
+        }
+        static async getArticle(id) {
+            return http.get(`/article/${id}`);
+        }
+        static async addArticle(data) {
+            return http.post('/article', data);
+        }
+        static async updateArticle(id, data) {
+            return http.patch(`/article/${id}`, data);
+        }
+        static async updateArticleViews(id) {
+            return http.post(`/article/${id}/views`);
+        }
+        static async updateArticleLikes(id, type) {
+            return http.post(`/article/${id}/likes`, { type });
+        }
+        static async checkPassword(id, password) {
+            return http.post(`/article/${id}/checkPassword`, { password });
+        }
+        static async deleteArticle(id) {
+            return http.delete(`/article/${id}`);
+        }
+    }
+    class CategoryProvider {
+        static async getCategory(params) {
+            return http.get('/category', { params });
+        }
+        static async add(data) {
+            return http.post('/category', data);
+        }
+        static async getCategoryById(id) {
+            return http.get(`/category/${id}`);
+        }
+        static async update(id, data) {
+            return http.patch(`/category/${id}`, data);
+        }
+        static async delete(id) {
+            return http.delete(`/category/${id}`);
+        }
+    }
+    class TagProvider {
+        static async getTags(params) {
+            return http.get('/tag', { params });
+        }
+        static async getTagWithArticles(id, needFilter = false) {
+            return http.get(`/tag/${id}/article`, needFilter ? { params: { status: 'publish' } } : {});
+        }
+        static async addTag(data) {
+            return http.post('/tag', data);
+        }
+        static async getTagById(id) {
+            return http.get(`/tag/${id}`);
+        }
+        static async updateTag(id, data) {
+            return http.patch(`/tag/${id}`, data);
+        }
+        static async deleteTag(id) {
+            return http.delete(`/tag/${id}`);
+        }
+    }
+    class PageProvider {
+        static async getPages(params) {
+            return http.get('/page', { params });
+        }
+        static async getAllPublisedPages() {
+            return http.get('/page', { params: { status: 'publish' } }).then((res) => {
+                const [pages, total] = res;
+                return [pages.sort((a, b) => -a.order + b.order), total];
+            });
+        }
+        static async getPage(id) {
+            return http.get(`/page/${id}`);
+        }
+        static async addPage(data) {
+            return http.post('/page', data);
+        }
+        static async updatePage(id, data) {
+            return http.patch(`/page/${id}`, data);
+        }
+        static async updatePageViews(id) {
+            return http.post(`/page/${id}/views`);
+        }
+        static async deletePage(id) {
+            return http.delete(`/page/${id}`);
+        }
+    }
+    class CommentProvider {
+        static async getComments(params) {
+            return http.get('/comment', { params });
+        }
+        static async getComment(id) {
+            return http.get(`/comment/${id}`);
+        }
+        static async getArticleComments(hostId, params) {
+            return http.get(`/comment/host/${hostId}`, { params });
+        }
+        static async addComment(data) {
+            return http.post('/comment', data);
+        }
+        static async updateComment(id, data) {
+            return http.patch(`/comment/${id}`, data);
+        }
+        static async deleteComment(id) {
+            return http.delete(`/comment/${id}`);
+        }
+    }
+    class UserProvider {
+        static async login(data) {
+            return http.post('/auth/login', data);
+        }
+        static async loginWithGithub(code) {
+            return http.post('/auth/github', { code });
+        }
+        static async register(data) {
+            return http.post('/user/register', data);
+        }
+        static getUsers(params) {
+            return http.get('/user', { params });
+        }
+        static async update(data) {
+            return http.post('/user/update', data);
+        }
+        static async updatePassword(data) {
+            return http.post('/user/password', data);
+        }
+    }
+    class KnowledgeProvider {
+        static createBook(data) {
+            return http.post('/knowledge/book', data);
+        }
+        static createChapters(data) {
+            return http.post('/knowledge/chapter', data);
+        }
+        static async deleteKnowledge(id) {
+            return http.delete(`/knowledge/${id}`);
+        }
+        static async updateKnowledge(id, data) {
+            return http.patch(`/knowledge/${id}`, data);
+        }
+        static async getKnowledges(params = {}) {
+            return http.get('/knowledge', { params });
+        }
+        static async getKnowledge(id) {
+            return http.get(`/knowledge/${id}`);
+        }
+        static async updateKnowledgeViews(id) {
+            return http.post(`/knowledge/${id}/views`);
+        }
+        static async updateKnowledgeLikes(id, type) {
+            return http.post(`/knowledge/${id}/likes`, { type });
+        }
+    }
+    class SearchProvider {
+        static async searchArticles(keyword) {
+            return http.get('/search/article', { params: { keyword } });
+        }
+    }
+    class FileProvider {
+        static async uploadFile(file, unique = 0) {
+            return http.post('/file/upload', file, {
+                headers: { 'Content-Type': 'multipart/form-data' },
+                params: { unique },
+            });
+        }
+        static async getFiles(params) {
+            return http.get('/file', { params });
+        }
+        static async deleteFile(id) {
+            return http.delete(`/file/${id}`);
+        }
+    }
+    class ViewProvider {
+        static async getViews(params) {
+            return http.get('/view', { params });
+        }
+        static async addView(data) {
+            return http.post('/view', data);
+        }
+        static async getViewsByUrl(url) {
+            return http.get('/view/url', { params: { url } });
+        }
+        static async deleteView(id) {
+            return http.delete(`/view/${id}`);
+        }
+    }
+    class MailProvider {
+        static async getMails(params) {
+            return http.get('/mail', { params });
+        }
+        static async deleteMail(id) {
+            return http.delete(`/mail/${id}`);
+        }
+    }
+    class SmtpProvider {
+        static async testSendMail(user) {
+            return http.post('/smtp/test', user);
+        }
+    }
+    class PosterProvider {
+        static async createPoster(data) {
+            return http.post('/poster', data);
+        }
+    }
+    return {
+        SettingProvider,
+        ArticleProvider,
+        CategoryProvider,
+        TagProvider,
+        PageProvider,
+        CommentProvider,
+        UserProvider,
+        KnowledgeProvider,
+        SearchProvider,
+        FileProvider,
+        ViewProvider,
+        MailProvider,
+        SmtpProvider,
+        PosterProvider,
+    };
+}

package/dist/theme/providers/setup.d.ts

@@ -0,0 +1,124 @@
+import type { CreateThemeAxiosClientOptions } from '../api/httpClient';
+export type CreateThemeHttpStackOptions = CreateThemeAxiosClientOptions & {
+    onError?: (message: string) => void;
+    onUnauthorized?: () => void;
+};
+/**
+ * One-call HTTP client + REST providers for theme pages.
+ * Mirrors the stack used inside `createReactPressApp`, with optional toast hooks.
+ */
+export declare function createThemeHttpStack(options?: CreateThemeHttpStackOptions): {
+    SettingProvider: {
+        new (): {};
+        getSetting(): Promise<import("../..").ISetting>;
+        updateSetting(data: Partial<import("../..").ISetting>): Promise<import("../..").ISetting>;
+    };
+    ArticleProvider: {
+        new (): {};
+        getArticles(params: Record<string, unknown>): Promise<[import("../..").IArticle[], number]>;
+        getAllRecommendArticles(): Promise<import("../..").IArticle[]>;
+        getArticlesByCategory(category: string, params: Record<string, unknown>): Promise<[import("../..").IArticle[], number]>;
+        getArticlesByTag(tag: string, params: Record<string, unknown>): Promise<[import("../..").IArticle[], number]>;
+        getRecommend(articleId?: string | null, pageSize?: number): Promise<import("../..").IArticle[]>;
+        getArchives(): Promise<Record<string, Record<string, import("../..").IArticle[]>>>;
+        getArticle(id: string): Promise<import("../..").IArticle>;
+        addArticle(data: Partial<import("../..").IArticle>): Promise<import("../..").IArticle>;
+        updateArticle(id: string, data: Partial<import("../..").IArticle>): Promise<import("../..").IArticle>;
+        updateArticleViews(id: string): Promise<import("../..").IArticle>;
+        updateArticleLikes(id: string, type: string): Promise<import("../..").IArticle>;
+        checkPassword(id: string, password: string): Promise<{
+            pass: boolean;
+        } & import("../..").IArticle>;
+        deleteArticle(id: string): Promise<import("../..").IArticle>;
+    };
+    CategoryProvider: {
+        new (): {};
+        getCategory(params?: Record<string, unknown>): Promise<import("../..").ICategory[]>;
+        add(data: Partial<import("../..").ICategory>): Promise<import("../..").ICategory>;
+        getCategoryById(id: string): Promise<import("../..").ICategory>;
+        update(id: string, data: Partial<import("../..").ICategory>): Promise<import("../..").ICategory>;
+        delete(id: string): Promise<import("../..").ICategory>;
+    };
+    TagProvider: {
+        new (): {};
+        getTags(params?: Record<string, unknown>): Promise<import("../..").ITag[]>;
+        getTagWithArticles(id: string, needFilter?: boolean): Promise<import("../..").ITag>;
+        addTag(data: Partial<import("../..").ITag>): Promise<import("../..").ITag>;
+        getTagById(id: string): Promise<import("../..").ITag>;
+        updateTag(id: string, data: Partial<import("../..").ITag>): Promise<import("../..").ITag>;
+        deleteTag(id: string): Promise<import("../..").ITag>;
+    };
+    PageProvider: {
+        new (): {};
+        getPages(params: Record<string, unknown>): Promise<[import("../..").IPage[], number]>;
+        getAllPublisedPages(): Promise<[import("../..").IPage[], number]>;
+        getPage(id: string): Promise<import("../..").IPage>;
+        addPage(data: Partial<import("../..").IPage>): Promise<import("../..").IPage>;
+        updatePage(id: string, data: Partial<import("../..").IPage>): Promise<import("../..").IPage>;
+        updatePageViews(id: string): Promise<import("../..").IPage>;
+        deletePage(id: string): Promise<import("../..").IPage>;
+    };
+    CommentProvider: {
+        new (): {};
+        getComments(params: Record<string, unknown>): Promise<[import("../..").IComment[], number]>;
+        getComment(id: string): Promise<import("../..").IComment>;
+        getArticleComments(hostId: string, params: Record<string, unknown>): Promise<[import("../..").IComment[], number]>;
+        addComment(data: Partial<import("../..").IComment>): Promise<import("../..").IComment>;
+        updateComment(id: string, data: Partial<import("../..").IComment>): Promise<import("../..").IComment>;
+        deleteComment(id: string): Promise<import("../..").IComment>;
+    };
+    UserProvider: {
+        new (): {};
+        login(data: Record<string, unknown>): Promise<import("../..").IUser>;
+        loginWithGithub(code: string): Promise<import("../..").IUser>;
+        register(data: Record<string, unknown>): Promise<import("../..").IUser>;
+        getUsers(params: Record<string, unknown>): Promise<[import("../..").IUser[], number]>;
+        update(data: Record<string, unknown>): Promise<import("../..").IUser>;
+        updatePassword(data: Record<string, unknown>): Promise<import("../..").IUser>;
+    };
+    KnowledgeProvider: {
+        new (): {};
+        createBook(data: Partial<import("../..").IKnowledge>): Promise<import("../..").IKnowledge>;
+        createChapters(data: Partial<import("../..").IKnowledge>[]): Promise<import("../..").IKnowledge[]>;
+        deleteKnowledge(id: string): Promise<import("../..").IKnowledge>;
+        updateKnowledge(id: string, data: Partial<import("../..").IKnowledge>): Promise<import("../..").IKnowledge>;
+        getKnowledges(params?: Record<string, unknown>): Promise<[import("../..").IKnowledge[], number]>;
+        getKnowledge(id: string): Promise<import("../..").IKnowledge>;
+        updateKnowledgeViews(id: string): Promise<import("../..").IKnowledge>;
+        updateKnowledgeLikes(id: string, type: string): Promise<import("../..").IKnowledge>;
+    };
+    SearchProvider: {
+        new (): {};
+        searchArticles(keyword: string): Promise<import("../..").IArticle[]>;
+    };
+    FileProvider: {
+        new (): {};
+        uploadFile(file: FormData, unique?: number): Promise<import("../..").IFile>;
+        getFiles(params: Record<string, unknown>): Promise<[import("../..").IFile[], number]>;
+        deleteFile(id: string): Promise<import("../..").IFile>;
+    };
+    ViewProvider: {
+        new (): {};
+        getViews(params: Record<string, unknown>): Promise<[import("../..").IView[], number]>;
+        addView(data: Record<string, unknown>): Promise<import("../..").IView>;
+        getViewsByUrl(url: string): Promise<import("../..").IView[]>;
+        deleteView(id: string): Promise<import("../..").IView>;
+    };
+    MailProvider: {
+        new (): {};
+        getMails(params: Record<string, unknown>): Promise<[Record<string, unknown>[], number]>;
+        deleteMail(id: string): Promise<Record<string, unknown>>;
+    };
+    SmtpProvider: {
+        new (): {};
+        testSendMail(user: Record<string, unknown>): Promise<import("../..").IFile>;
+    };
+    PosterProvider: {
+        new (): {};
+        createPoster(data: Record<string, unknown>): Promise<{
+            name: string;
+            url: string;
+        }>;
+    };
+    httpProvider: import("axios").AxiosInstance;
+};

package/dist/theme/providers/setup.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThemeHttpStack = createThemeHttpStack;
+const authSession_1 = require("../visitor/authSession");
+const httpClient_1 = require("../api/httpClient");
+const index_1 = require("./index");
+/**
+ * One-call HTTP client + REST providers for theme pages.
+ * Mirrors the stack used inside `createReactPressApp`, with optional toast hooks.
+ */
+function createThemeHttpStack(options = {}) {
+    const { onError, onUnauthorized, ...httpOptions } = options;
+    const httpProvider = (0, httpClient_1.createThemeAxiosClient)({
+        ...httpOptions,
+        onError,
+        onUnauthorized: onUnauthorized ??
+            (() => {
+                (0, authSession_1.clearThemeSession)();
+                if (typeof window !== 'undefined') {
+                    window.location.reload();
+                }
+            }),
+    });
+    const providers = (0, index_1.createThemeProviders)(httpProvider);
+    return {
+        httpProvider,
+        ...providers,
+    };
+}

package/dist/theme/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { SiteThemeState, ThemeMods } from './extension/theme';
+export interface ThemeRuntime {
+    /** Theme package id (from `theme.json` or env). */
+    themeId: string;
+    /** Published active theme on the site. */
+    activeThemeId: string;
+    /** Customizer values for `themeId`. */
+    mods: ThemeMods;
+    /** `previewThemeId` differs from `activeThemeId` in customizer preview. */
+    isPreview: boolean;
+    themeState: SiteThemeState;
+}
+export interface ResolveThemeRuntimeOptions {
+    themeId: string;
+    /** When true (default), use `previewThemeId` from global settings when set. */
+    honorPreview?: boolean;
+}
+export declare function resolveThemeRuntime(globalSettingRaw: unknown, options: ResolveThemeRuntimeOptions): ThemeRuntime;

package/dist/theme/runtime.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveThemeRuntime = resolveThemeRuntime;
+const theme_1 = require("./extension/theme");
+function resolveThemeRuntime(globalSettingRaw, options) {
+    const themeState = (0, theme_1.getThemeStateFromGlobalSetting)(globalSettingRaw);
+    const activeThemeId = themeState.activeTheme;
+    const previewId = themeState.previewThemeId;
+    const honorPreview = options.honorPreview !== false;
+    const effectiveId = honorPreview && previewId ? previewId : options.themeId || activeThemeId;
+    const isPreview = Boolean(previewId && previewId !== activeThemeId);
+    return {
+        themeId: effectiveId,
+        activeThemeId,
+        mods: themeState.mods[effectiveId] ?? {},
+        isPreview,
+        themeState,
+    };
+}

package/dist/theme/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/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/server.d.ts

@@ -0,0 +1,65 @@
+/**
+ * SSR-safe theme exports for App Router / server components.
+ * Does not re-export `@fecommunity/reactpress-toolkit/ui` (React context / hooks).
+ * Client components should import UI from `@fecommunity/reactpress-toolkit/ui` directly.
+ */
+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';