@fecommunity/reactpress 3.7.0 → 4.0.0-beta.0

package/server/dist/modules/extension/theme.service.js

@@ -0,0 +1,1039 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ThemeService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeService = void 0;
+const theme_1 = require("../../../../toolkit/dist/theme");
+const theme_2 = require("../../../../toolkit/dist/theme");
+const node_1 = require("../../../../toolkit/dist/theme/node");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const typeorm_2 = require("typeorm");
+const project_root_util_1 = require("../../utils/project-root.util");
+const setting_service_1 = require("../setting/setting.service");
+const setting_entity_1 = require("../setting/setting.entity");
+const theme_placeholder_cover_js_1 = require("../../../../cli/out/lib/theme-placeholder-cover.js");
+const theme_registry_bridge_1 = require("./theme-registry.bridge");
+const preview_draft_store_1 = require("./preview-draft.store");
+function projectRoot() {
+    return (0, project_root_util_1.resolveProjectRoot)();
+}
+function monorepoRoot() {
+    return (0, project_root_util_1.resolveMonorepoRoot)();
+}
+function resolveThemeInstallScript() {
+    const candidates = [
+        path.join(monorepoRoot(), 'cli', 'lib', 'theme-install.js'),
+        path.join(projectRoot(), 'cli', 'lib', 'theme-install.js'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return candidates[0];
+}
+function isResolvableThemeDirEntry(entry, parentDir) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink())
+        return false;
+    try {
+        return fs.statSync(path.join(parentDir, entry.name)).isDirectory();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+const THEME_ID_RE = /^[a-z0-9][a-z0-9-]*$/i;
+const PREVIEW_POOL_PORTS = [3003];
+const PREVIEW_POOL_MANIFEST = path.join('.reactpress', 'preview-pool.json');
+const THEME_RUNTIME_REL = path.join('.reactpress', 'runtime');
+const LEGACY_THEMES_RUNTIME_REL = path.join('themes', 'runtime');
+const THEMES_RESERVED_SUBDIRS = new Set(['starter', 'bundled', 'core', 'theme-starter']);
+const THEMES_LEGACY_STARTER_SUBDIRS = ['starter', 'bundled', 'core'];
+let ThemeService = ThemeService_1 = class ThemeService {
+    constructor(settingRepository, settingService) {
+        this.settingRepository = settingRepository;
+        this.settingService = settingService;
+    }
+    themesRoot() {
+        return path.join(projectRoot(), 'themes');
+    }
+    templatesDir() {
+        return this.themesRoot();
+    }
+    runtimeDir() {
+        return path.join(projectRoot(), THEME_RUNTIME_REL);
+    }
+    ensureSiteRuntimeLink(id, sourceDir) {
+        const targetDir = path.join(this.runtimeDir(), id);
+        fs.mkdirSync(this.runtimeDir(), { recursive: true });
+        if (fs.existsSync(targetDir)) {
+            return targetDir;
+        }
+        try {
+            fs.symlinkSync(sourceDir, targetDir, 'dir');
+        }
+        catch (_a) {
+            return sourceDir;
+        }
+        this.ensureRuntimeThemeTsconfigBase();
+        return targetDir;
+    }
+    legacyStarterDirs() {
+        return THEMES_LEGACY_STARTER_SUBDIRS.map((name) => path.join(this.themesRoot(), name));
+    }
+    legacyBundledDir() {
+        return path.join(projectRoot(), 'templates');
+    }
+    applyTemplateAppearanceSchema(manifest) {
+        var _a, _b;
+        const templatePath = path.join(this.templatesDir(), manifest.id);
+        const template = this.readManifest(templatePath);
+        if (!template)
+            return manifest;
+        let next = manifest;
+        if ((_b = (_a = template.appearance) === null || _a === void 0 ? void 0 : _a.sections) === null || _b === void 0 ? void 0 : _b.length) {
+            next = Object.assign(Object.assign({}, next), { appearance: template.appearance });
+        }
+        if (template.options) {
+            next = Object.assign(Object.assign({}, next), { options: template.options });
+        }
+        return next;
+    }
+    readManifest(themeDir) {
+        const manifestPath = path.join(themeDir, 'theme.json');
+        if (!fs.existsSync(manifestPath))
+            return null;
+        try {
+            const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            const parsed = (0, theme_2.parseThemeManifest)(raw);
+            if (parsed)
+                return parsed;
+            if (raw && typeof raw.id === 'string') {
+                return (0, theme_2.parseThemeManifest)(Object.assign(Object.assign({}, raw), { id: raw.id }));
+            }
+            const id = path.basename(themeDir);
+            return (0, theme_2.parseThemeManifest)(Object.assign({ id, name: id, version: '1.0.0' }, raw));
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    readNpmThemeLock() {
+        var _a;
+        const lockPath = path.join(projectRoot(), '.reactpress', 'themes.lock.json');
+        if (!fs.existsSync(lockPath))
+            return {};
+        try {
+            const raw = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+            const themes = (_a = raw.themes) !== null && _a !== void 0 ? _a : {};
+            const npmOnly = {};
+            for (const [id, entry] of Object.entries(themes)) {
+                if ((entry === null || entry === void 0 ? void 0 : entry.source) === 'npm' && entry.spec) {
+                    npmOnly[id] = {
+                        spec: entry.spec,
+                        resolvedVersion: entry.resolvedVersion,
+                        packageName: entry.packageName,
+                        installedAt: entry.installedAt,
+                    };
+                }
+            }
+            return npmOnly;
+        }
+        catch (_b) {
+            return {};
+        }
+    }
+    readThemeCatalogFile() {
+        return (0, theme_registry_bridge_1.readThemeCatalogEntries)(projectRoot());
+    }
+    getThemeCatalog() {
+        return this.readThemeCatalogFile();
+    }
+    findCatalogEntry(id) {
+        return (0, theme_registry_bridge_1.findThemeCatalogEntry)(id, projectRoot());
+    }
+    getThemeManifestFromSources(themeId) {
+        const dir = this.resolveThemeDir(themeId);
+        if (dir) {
+            return this.readManifest(dir);
+        }
+        const catalog = this.findCatalogEntry(themeId);
+        if (!catalog)
+            return null;
+        const manifest = (0, theme_registry_bridge_1.loadThemeRegistry)().catalogEntryToManifest(catalog);
+        return manifest ? manifest : null;
+    }
+    async ensureThemeMaterialized(id) {
+        const existing = this.resolveThemeDir(id);
+        if (existing)
+            return existing;
+        const templatePath = path.join(this.templatesDir(), id);
+        if (fs.existsSync(templatePath) && !THEMES_RESERVED_SUBDIRS.has(id)) {
+            await this.installTheme(id);
+            const installed = this.resolveThemeDir(id);
+            if (installed)
+                return installed;
+        }
+        const catalog = this.findCatalogEntry(id);
+        if (catalog === null || catalog === void 0 ? void 0 : catalog.npm) {
+            await this.installThemeFromNpm(catalog.npm);
+            const installed = this.resolveThemeDir(id);
+            if (installed)
+                return installed;
+        }
+        throw new common_1.NotFoundException(`Theme "${id}" not found`);
+    }
+    listDirThemes(dir, source, options) {
+        if (!fs.existsSync(dir))
+            return [];
+        const skip = options === null || options === void 0 ? void 0 : options.skipDirNames;
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => isResolvableThemeDirEntry(d, dir) && !(skip && skip.has(d.name)))
+            .map((d) => this.readManifest(path.join(dir, d.name)))
+            .filter((m) => m !== null);
+    }
+    async getSettingRow() {
+        return this.settingService.getSettingRow();
+    }
+    parseGlobalSetting(row) {
+        if (!row.globalSetting)
+            return {};
+        try {
+            return JSON.parse(row.globalSetting);
+        }
+        catch (_a) {
+            return {};
+        }
+    }
+    async getThemeState() {
+        const row = await this.getSettingRow();
+        return (0, theme_2.getThemeStateFromGlobalSetting)(this.parseGlobalSetting(row));
+    }
+    async saveThemeState(patch) {
+        const row = await this.getSettingRow();
+        const merged = (0, theme_2.mergeThemeStateIntoGlobalSetting)(this.parseGlobalSetting(row), patch);
+        row.globalSetting = JSON.stringify(merged);
+        await this.settingRepository.save(row);
+        return merged.theme;
+    }
+    listLocalThemes() {
+        return this.listBundledThemes();
+    }
+    listBundledThemes() {
+        const { bundled: local } = (0, theme_registry_bridge_1.readThemesPackageMeta)(projectRoot());
+        const manifests = [];
+        for (const id of local) {
+            const manifest = this.readManifest(path.join(this.templatesDir(), id));
+            if (manifest)
+                manifests.push(manifest);
+        }
+        return manifests;
+    }
+    isRegistryLocalTheme(id) {
+        const { bundled: local } = (0, theme_registry_bridge_1.readThemesPackageMeta)(projectRoot());
+        return local.includes(id);
+    }
+    hasOfficialTag(tags) {
+        return (tags !== null && tags !== void 0 ? tags : []).some((tag) => /^(official|官方)$/i.test(String(tag).trim()));
+    }
+    resolveThemeOfficial(manifest, catalog) {
+        if (this.isRegistryLocalTheme(manifest.id))
+            return true;
+        if ((catalog === null || catalog === void 0 ? void 0 : catalog.featured) === true)
+            return true;
+        if (this.hasOfficialTag(manifest.tags))
+            return true;
+        const catalogEntry = this.findCatalogEntry(manifest.id);
+        if ((catalogEntry === null || catalogEntry === void 0 ? void 0 : catalogEntry.featured) === true)
+            return true;
+        return this.hasOfficialTag(catalogEntry === null || catalogEntry === void 0 ? void 0 : catalogEntry.tags);
+    }
+    catalogMetaFromEntry(entry) {
+        return {
+            dependency: entry.dependency,
+            npm: entry.npm,
+            featured: entry.featured,
+            themeUri: entry.themeUri,
+            previewUrl: entry.previewUrl,
+        };
+    }
+    async listThemes() {
+        const state = await this.getThemeState();
+        const installedSet = new Set(state.installedThemes);
+        const npmLock = this.readNpmThemeLock();
+        const byId = new Map();
+        const add = (manifest, source, npm, catalog) => {
+            const installed = installedSet.has(manifest.id) || source === 'installed';
+            const merged = this.applyTemplateAppearanceSchema(manifest);
+            byId.set(merged.id, Object.assign(Object.assign({}, merged), { source,
+                installed, active: state.activeTheme === merged.id, official: this.resolveThemeOfficial(merged, catalog), coverUrl: `/api/extension/themes/${merged.id}/cover`, npm,
+                catalog }));
+        };
+        for (const m of this.listLocalThemes()) {
+            add(m, 'local');
+        }
+        for (const m of this.listDirThemes(this.runtimeDir(), 'installed')) {
+            const npm = npmLock[m.id];
+            const catalogEntry = this.findCatalogEntry(m.id);
+            add(m, 'installed', npm, catalogEntry
+                ? this.catalogMetaFromEntry(catalogEntry)
+                : npm
+                    ? { npm: npm.spec }
+                    : undefined);
+        }
+        for (const entry of this.readThemeCatalogFile()) {
+            if (byId.has(entry.id))
+                continue;
+            add({
+                id: entry.id,
+                name: entry.name,
+                version: entry.version,
+                description: entry.description,
+                author: entry.author,
+                themeUri: entry.themeUri,
+                tags: entry.tags,
+                requires: entry.requires,
+            }, 'npm', undefined, { dependency: entry.dependency, npm: entry.npm, featured: entry.featured, themeUri: entry.themeUri, previewUrl: entry.previewUrl });
+        }
+        return Array.from(byId.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async getTheme(id) {
+        const items = await this.listThemes();
+        const found = items.find((t) => t.id === id);
+        if (!found)
+            throw new common_1.NotFoundException(`Theme "${id}" not found`);
+        return found;
+    }
+    async getThemeAdminLocale(themeId, locale) {
+        if (!this.isValidThemeId(themeId)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${themeId}"`);
+        }
+        const dirs = this.themeLocaleSearchDirs(themeId);
+        if (dirs.length === 0) {
+            throw new common_1.NotFoundException(`Theme "${themeId}" not found`);
+        }
+        const safeLocale = /^[a-z]{2}(?:-[a-z]{2})?$/i.test(locale) ? locale : 'en';
+        for (const dir of dirs) {
+            const messages = (0, node_1.readThemeAdminLocaleFile)(dir, safeLocale);
+            if (messages) {
+                return { themeId, locale: safeLocale, messages };
+            }
+        }
+        return { themeId, locale: safeLocale, messages: {} };
+    }
+    themeLocaleSearchDirs(themeId) {
+        const seen = new Set();
+        const ordered = [];
+        const push = (dir) => {
+            if (!dir || seen.has(dir))
+                return;
+            seen.add(dir);
+            ordered.push(dir);
+        };
+        const template = path.join(this.templatesDir(), themeId);
+        if (fs.existsSync(template) &&
+            !THEMES_RESERVED_SUBDIRS.has(themeId) &&
+            this.isUnderDir(template, this.templatesDir())) {
+            push(template);
+        }
+        push(this.resolveThemeDir(themeId));
+        return ordered;
+    }
+    getThemeManifestForConfig(themeId) {
+        const dir = this.resolveThemeDir(themeId);
+        if (!dir)
+            return null;
+        return this.applyTemplateAppearanceSchema(this.readManifest(dir));
+    }
+    async getThemeConfigurationSchema(themeId) {
+        if (!this.isValidThemeId(themeId)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${themeId}"`);
+        }
+        const manifest = this.getThemeManifestForConfig(themeId);
+        if (!manifest)
+            throw new common_1.NotFoundException(`Theme "${themeId}" not found`);
+        const schema = (0, theme_2.getConfigurationSchemaFromManifest)(manifest, themeId);
+        return { themeId, schema };
+    }
+    async getThemeConfiguration(themeId) {
+        if (!this.isValidThemeId(themeId)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${themeId}"`);
+        }
+        const manifest = this.getThemeManifestForConfig(themeId);
+        if (!manifest)
+            throw new common_1.NotFoundException(`Theme "${themeId}" not found`);
+        const row = await this.getSettingRow();
+        const configuration = (0, theme_2.getMergedThemeConfiguration)(this.parseGlobalSetting(row), themeId, {
+            manifest,
+        });
+        return { themeId, configuration };
+    }
+    async updateThemeConfiguration(themeId, patch, options) {
+        var _a, _b, _c;
+        if (!this.isValidThemeId(themeId)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${themeId}"`);
+        }
+        const manifest = this.getThemeManifestForConfig(themeId);
+        if (!manifest)
+            throw new common_1.NotFoundException(`Theme "${themeId}" not found`);
+        const schema = (0, theme_2.getConfigurationSchemaFromManifest)(manifest, themeId);
+        if (!schema) {
+            throw new common_1.BadRequestException(`Theme "${themeId}" does not declare options schema`);
+        }
+        const row = await this.getSettingRow();
+        const globalRaw = this.parseGlobalSetting(row);
+        const locale = (_a = options === null || options === void 0 ? void 0 : options.locale) !== null && _a !== void 0 ? _a : 'zh';
+        if (options === null || options === void 0 ? void 0 : options.replace) {
+            const seed = (_b = (0, theme_2.getThemeConfigurationSeed)(themeId, locale)) !== null && _b !== void 0 ? _b : (0, theme_2.getMergedThemeConfiguration)(globalRaw, themeId, { locale, manifest });
+            const validation = (0, theme_2.validateThemeConfiguration)(schema, seed);
+            if (!validation.valid) {
+                throw new common_1.BadRequestException((_c = validation.message) !== null && _c !== void 0 ? _c : 'Invalid configuration');
+            }
+            const mergedGlobal = (0, theme_2.mergeConfigIntoGlobalSetting)(globalRaw, themeId, seed);
+            row.globalSetting = JSON.stringify(mergedGlobal);
+            await this.settingRepository.save(row);
+            return { themeId, configuration: seed };
+        }
+        const result = (0, theme_2.validateAndMergeThemeConfiguration)(themeId, globalRaw, patch, manifest);
+        if (!result.ok) {
+            throw new common_1.BadRequestException('message' in result ? result.message : 'Invalid configuration');
+        }
+        const mergedGlobal = (0, theme_2.mergeConfigIntoGlobalSetting)(globalRaw, themeId, result.config);
+        row.globalSetting = JSON.stringify(mergedGlobal);
+        await this.settingRepository.save(row);
+        return { themeId, configuration: result.config };
+    }
+    isValidThemeId(id) {
+        return typeof id === 'string' && THEME_ID_RE.test(id) && id.length <= 64;
+    }
+    isUnderDir(target, base) {
+        const rel = path.relative(path.resolve(base), path.resolve(target));
+        return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+    }
+    isSafeThemeDirRel(themeDirRel) {
+        if (themeDirRel == null)
+            return true;
+        if (themeDirRel.includes('..') || path.isAbsolute(themeDirRel))
+            return false;
+        if (themeDirRel.startsWith(`${THEME_RUNTIME_REL}/`)) {
+            return true;
+        }
+        if (themeDirRel.startsWith(`${LEGACY_THEMES_RUNTIME_REL}/`)) {
+            return true;
+        }
+        if (themeDirRel.startsWith('themes/') && !themeDirRel.startsWith(`${LEGACY_THEMES_RUNTIME_REL}/`)) {
+            const rest = themeDirRel.slice('themes/'.length);
+            const top = rest.split('/')[0];
+            if (top && !THEMES_RESERVED_SUBDIRS.has(top)) {
+                return true;
+            }
+        }
+        const legacyPrefixes = THEMES_LEGACY_STARTER_SUBDIRS.map((name) => `themes/${name}/`);
+        if (legacyPrefixes.some((prefix) => themeDirRel.startsWith(prefix))) {
+            return true;
+        }
+        return themeDirRel.startsWith('templates/');
+    }
+    resolveThemeDir(id) {
+        if (!this.isValidThemeId(id))
+            return null;
+        const runtime = path.join(this.runtimeDir(), id);
+        if (fs.existsSync(runtime) && this.isUnderDir(runtime, this.runtimeDir())) {
+            return runtime;
+        }
+        const legacyRuntimeRoot = path.join(projectRoot(), LEGACY_THEMES_RUNTIME_REL);
+        const legacyRuntime = path.join(legacyRuntimeRoot, id);
+        if (fs.existsSync(legacyRuntime) && this.isUnderDir(legacyRuntime, legacyRuntimeRoot)) {
+            return legacyRuntime;
+        }
+        const template = path.join(this.templatesDir(), id);
+        if (fs.existsSync(template) &&
+            !THEMES_RESERVED_SUBDIRS.has(id) &&
+            this.isUnderDir(template, this.templatesDir())) {
+            return template;
+        }
+        for (const legacyStarter of this.legacyStarterDirs()) {
+            const legacy = path.join(legacyStarter, id);
+            if (fs.existsSync(legacy) && this.isUnderDir(legacy, legacyStarter)) {
+                return legacy;
+            }
+        }
+        const legacyBundled = path.join(this.legacyBundledDir(), id);
+        if (fs.existsSync(legacyBundled) && this.isUnderDir(legacyBundled, this.legacyBundledDir())) {
+            return legacyBundled;
+        }
+        const site = projectRoot();
+        const mono = monorepoRoot();
+        if (mono !== site) {
+            const monoRuntime = path.join(mono, THEME_RUNTIME_REL, id);
+            if (fs.existsSync(monoRuntime) && fs.statSync(monoRuntime).isDirectory()) {
+                return this.ensureSiteRuntimeLink(id, monoRuntime);
+            }
+            const monoTheme = path.join(mono, 'themes', id);
+            if (fs.existsSync(monoTheme) &&
+                fs.statSync(monoTheme).isDirectory() &&
+                !THEMES_RESERVED_SUBDIRS.has(id)) {
+                return monoTheme;
+            }
+        }
+        return null;
+    }
+    async installTheme(id) {
+        if (!this.isValidThemeId(id)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${id}"`);
+        }
+        const templatePath = path.join(this.templatesDir(), id);
+        if (!fs.existsSync(templatePath) || THEMES_RESERVED_SUBDIRS.has(id)) {
+            const catalog = this.findCatalogEntry(id);
+            if (catalog === null || catalog === void 0 ? void 0 : catalog.npm) {
+                return this.installThemeFromNpm(catalog.npm);
+            }
+            throw new common_1.NotFoundException(`Theme template "${id}" not found`);
+        }
+        const targetDir = path.join(this.runtimeDir(), id);
+        fs.mkdirSync(this.runtimeDir(), { recursive: true });
+        if (fs.existsSync(targetDir)) {
+            this.removeDir(targetDir);
+        }
+        this.materializeRuntimeTheme(templatePath, targetDir);
+        this.ensureRuntimeThemeTsconfigBase();
+        const state = await this.getThemeState();
+        const installedThemes = state.installedThemes.includes(id)
+            ? state.installedThemes
+            : [...state.installedThemes, id];
+        return this.saveThemeState({ installedThemes });
+    }
+    async installThemeFromNpm(spec, options) {
+        var _a;
+        const trimmed = typeof spec === 'string' ? spec.trim() : '';
+        if (!trimmed) {
+            throw new common_1.BadRequestException('npm spec is required');
+        }
+        const resolvedSpec = (_a = (0, theme_registry_bridge_1.resolveThemeCatalogInstallSpec)(trimmed, projectRoot())) !== null && _a !== void 0 ? _a : trimmed;
+        const installScript = resolveThemeInstallScript();
+        if (!fs.existsSync(installScript)) {
+            throw new common_1.BadRequestException('Theme npm installer is not available in this deployment');
+        }
+        let result;
+        try {
+            const { installThemeFromNpm } = require(installScript);
+            result = await installThemeFromNpm(projectRoot(), resolvedSpec, {
+                skipDependencies: (options === null || options === void 0 ? void 0 : options.skipDependencies) === true,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new common_1.BadRequestException(message || 'Failed to install theme from npm');
+        }
+        const state = await this.getThemeState();
+        const installedThemes = state.installedThemes.includes(result.themeId)
+            ? state.installedThemes
+            : [...state.installedThemes, result.themeId];
+        const saved = await this.saveThemeState({ installedThemes });
+        return Object.assign(Object.assign({}, saved), { themeId: result.themeId, npmSpec: result.npmSpec });
+    }
+    writeThemeDevManifest(fileName, themeId) {
+        if (!this.isValidThemeId(themeId))
+            return;
+        const themeDir = this.resolveThemeDir(themeId);
+        if (!themeDir)
+            return;
+        const manifestDir = path.join(projectRoot(), '.reactpress');
+        const manifestPath = path.join(manifestDir, fileName);
+        const themeDirRel = path.relative(projectRoot(), themeDir);
+        if (!this.isSafeThemeDirRel(themeDirRel))
+            return;
+        if (fs.existsSync(manifestPath)) {
+            try {
+                const existing = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+                if (existing.activeTheme === themeId && existing.themeDir === themeDirRel) {
+                    return;
+                }
+            }
+            catch (_a) {
+            }
+        }
+        fs.mkdirSync(manifestDir, { recursive: true });
+        const payload = {
+            activeTheme: themeId,
+            themeDir: themeDirRel,
+            updatedAt: new Date().toISOString(),
+        };
+        fs.writeFileSync(manifestPath, JSON.stringify(payload, null, 2), 'utf8');
+    }
+    syncActiveThemeManifest(themeId) {
+        this.writeThemeDevManifest('active-theme.json', themeId);
+    }
+    ensureRuntimeThemeTsconfigBase() {
+        const baseSrc = path.join(projectRoot(), 'tsconfig.base.json');
+        if (!fs.existsSync(baseSrc))
+            return;
+        const runtimeBase = path.join(this.runtimeDir(), 'tsconfig.base.json');
+        fs.mkdirSync(this.runtimeDir(), { recursive: true });
+        fs.copyFileSync(baseSrc, runtimeBase);
+    }
+    scheduleProductionClientRestart() {
+        if (process.env.NODE_ENV !== 'production')
+            return;
+        if (process.env.REACTPRESS_SKIP_CLIENT_RESTART === '1')
+            return;
+        const root = projectRoot();
+        const cliBin = path.join(root, 'cli', 'bin', 'reactpress.js');
+        if (!fs.existsSync(cliBin))
+            return;
+        const child = (0, child_process_1.spawn)(process.execPath, [cliBin, 'client', 'restart', '--pm2'], {
+            cwd: root,
+            detached: true,
+            stdio: 'ignore',
+            env: Object.assign(Object.assign({}, process.env), { REACTPRESS_ORIGINAL_CWD: root }),
+        });
+        child.unref();
+    }
+    syncPreviewThemeManifest(themeId) {
+        this.writeThemeDevManifest('preview-theme.json', themeId);
+    }
+    clearPreviewThemeManifest() {
+        const manifestPath = path.join(projectRoot(), '.reactpress', 'preview-theme.json');
+        if (fs.existsSync(manifestPath)) {
+            fs.unlinkSync(manifestPath);
+        }
+    }
+    readLocalDevActiveThemeId() {
+        const manifestPath = path.join(projectRoot(), '.reactpress', 'active-theme.json');
+        if (!fs.existsSync(manifestPath))
+            return null;
+        try {
+            const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            const id = typeof raw.activeTheme === 'string' ? raw.activeTheme.trim() : '';
+            return this.isValidThemeId(id) ? id : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    readPreviewPoolManifest() {
+        const poolPath = path.join(projectRoot(), PREVIEW_POOL_MANIFEST);
+        if (!fs.existsSync(poolPath))
+            return {};
+        try {
+            const raw = JSON.parse(fs.readFileSync(poolPath, 'utf8'));
+            return raw && typeof raw === 'object' ? raw : {};
+        }
+        catch (_a) {
+            return {};
+        }
+    }
+    writePreviewPoolEntry(themeId, port, siteUrl) {
+        const poolPath = path.join(projectRoot(), PREVIEW_POOL_MANIFEST);
+        const pool = this.readPreviewPoolManifest();
+        let previewUrl;
+        try {
+            const url = new URL(siteUrl);
+            url.port = port;
+            previewUrl = `${url.origin}/`;
+        }
+        catch (_a) {
+            previewUrl = `http://127.0.0.1:${port}/`;
+        }
+        pool[themeId] = { port, url: previewUrl, updatedAt: new Date().toISOString() };
+        fs.mkdirSync(path.dirname(poolPath), { recursive: true });
+        fs.writeFileSync(poolPath, `${JSON.stringify(pool, null, 2)}\n`, 'utf8');
+    }
+    reservePreviewPortForTheme(themeId, siteUrl) {
+        const proxyPort = process.env.REACTPRESS_PREVIEW_PORT || '3003';
+        this.writePreviewPoolEntry(themeId, proxyPort, siteUrl);
+        return proxyPort;
+    }
+    resolvePreviewSiteUrl(siteUrl, themeId) {
+        if (themeId) {
+            const entry = this.readPreviewPoolManifest()[themeId];
+            if (typeof (entry === null || entry === void 0 ? void 0 : entry.url) === 'string' && entry.url.startsWith('http')) {
+                return entry.url.endsWith('/') ? entry.url : `${entry.url}/`;
+            }
+            if (entry === null || entry === void 0 ? void 0 : entry.port) {
+                try {
+                    const url = new URL(siteUrl);
+                    url.port = String(entry.port);
+                    return `${url.origin}/`;
+                }
+                catch (_a) {
+                    return `http://127.0.0.1:${entry.port}/`;
+                }
+            }
+        }
+        const previewPort = process.env.REACTPRESS_PREVIEW_PORT || '3003';
+        try {
+            const url = new URL(siteUrl);
+            url.port = previewPort;
+            return `${url.origin}/`;
+        }
+        catch (_b) {
+            return `http://127.0.0.1:${previewPort}/`;
+        }
+    }
+    async activateTheme(id) {
+        if (!this.isValidThemeId(id)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${id}"`);
+        }
+        await this.ensureThemeMaterialized(id);
+        const themeDir = this.resolveThemeDir(id);
+        if (!themeDir)
+            throw new common_1.NotFoundException(`Theme "${id}" not found`);
+        const state = await this.getThemeState();
+        const installedThemes = state.installedThemes.includes(id)
+            ? state.installedThemes
+            : [...state.installedThemes, id];
+        const saved = await this.saveThemeState({
+            activeTheme: id,
+            installedThemes,
+            previewThemeId: id,
+        });
+        this.clearPreviewThemeManifest();
+        this.syncActiveThemeManifest(id);
+        this.scheduleProductionClientRestart();
+        const row = await this.getSettingRow();
+        const siteUrl = this.resolveSiteUrlFromRow(row);
+        return Object.assign(Object.assign({}, saved), { siteUrl });
+    }
+    async getActiveThemePublic() {
+        const state = await this.getThemeState();
+        const themeDir = this.resolveThemeDir(state.activeTheme);
+        const row = await this.getSettingRow();
+        return {
+            activeTheme: state.activeTheme,
+            themeDir: themeDir ? path.relative(projectRoot(), themeDir) : null,
+            siteUrl: this.resolveSiteUrlFromRow(row),
+        };
+    }
+    async updateThemeMods(themeId, mods) {
+        var _a;
+        const state = await this.getThemeState();
+        const themeMods = Object.assign({}, ((_a = state.mods[themeId]) !== null && _a !== void 0 ? _a : {}));
+        for (const [key, value] of Object.entries(mods)) {
+            if (value === "") {
+                delete themeMods[key];
+            }
+            else {
+                themeMods[key] = value;
+            }
+        }
+        const nextMods = Object.assign(Object.assign({}, state.mods), { [themeId]: themeMods });
+        return this.saveThemeState({ mods: nextMods, previewThemeId: themeId });
+    }
+    async beginPreviewSession(themeId) {
+        var _a;
+        if (!this.isValidThemeId(themeId)) {
+            throw new common_1.BadRequestException(`Invalid theme id "${themeId}"`);
+        }
+        await this.ensureThemeMaterialized(themeId);
+        const themeDir = this.resolveThemeDir(themeId);
+        if (!themeDir)
+            throw new common_1.NotFoundException(`Theme "${themeId}" not found`);
+        const state = await this.getThemeState();
+        const saved = await this.saveThemeState({ previewThemeId: themeId });
+        const row = await this.getSettingRow();
+        const siteUrl = this.resolveSiteUrlFromRow(row);
+        const runtimeActiveTheme = (_a = this.readLocalDevActiveThemeId()) !== null && _a !== void 0 ? _a : state.activeTheme;
+        if (themeId !== runtimeActiveTheme) {
+            this.reservePreviewPortForTheme(themeId, siteUrl);
+            this.syncPreviewThemeManifest(themeId);
+        }
+        else {
+            this.clearPreviewThemeManifest();
+        }
+        return Object.assign(Object.assign({}, saved), { activeTheme: runtimeActiveTheme, siteUrl, previewSiteUrl: themeId !== runtimeActiveTheme ? this.resolvePreviewSiteUrl(siteUrl, themeId) : undefined });
+    }
+    async endPreviewSession() {
+        const state = await this.getThemeState();
+        this.clearPreviewThemeManifest();
+        const saved = await this.saveThemeState({ previewThemeId: state.activeTheme });
+        const row = await this.getSettingRow();
+        return Object.assign(Object.assign({}, saved), { siteUrl: this.resolveSiteUrlFromRow(row) });
+    }
+    getCoverPath(id) {
+        const dir = this.resolveThemeDir(id);
+        if (!dir)
+            return null;
+        const candidates = ['cover.png', 'cover.jpg', 'cover.webp', 'cover.jpeg'];
+        for (const file of candidates) {
+            const full = path.join(dir, file);
+            if (fs.existsSync(full))
+                return full;
+        }
+        const manifest = this.readManifest(dir);
+        if (manifest === null || manifest === void 0 ? void 0 : manifest.cover) {
+            const fromManifest = path.join(dir, manifest.cover);
+            if (fs.existsSync(fromManifest))
+                return fromManifest;
+        }
+        return null;
+    }
+    themeAppearanceDefaults(manifest) {
+        var _a, _b, _c;
+        const defaults = {};
+        for (const section of (_b = (_a = manifest === null || manifest === void 0 ? void 0 : manifest.appearance) === null || _a === void 0 ? void 0 : _a.sections) !== null && _b !== void 0 ? _b : []) {
+            for (const setting of (_c = section.settings) !== null && _c !== void 0 ? _c : []) {
+                if (setting.default)
+                    defaults[setting.id] = setting.default;
+            }
+        }
+        return defaults;
+    }
+    buildPlaceholderCoverSvg(id) {
+        var _a;
+        const manifest = this.getThemeManifestFromSources(id);
+        const defaults = this.themeAppearanceDefaults(manifest);
+        return (0, theme_placeholder_cover_js_1.buildThemePlaceholderCoverSvg)({
+            id,
+            name: (_a = manifest === null || manifest === void 0 ? void 0 : manifest.name) !== null && _a !== void 0 ? _a : id,
+            primary: defaults.primaryColor,
+            accent: defaults.accentColor,
+            version: manifest === null || manifest === void 0 ? void 0 : manifest.version,
+        });
+    }
+    resolveSiteUrlFromRow(row) {
+        return (process.env.NGINX_ENTRY_URL ||
+            process.env.REACTPRESS_NGINX_ENTRY_URL ||
+            (process.env.NGINX_PORT ? `http://localhost:${process.env.NGINX_PORT}` : null) ||
+            row.systemUrl ||
+            process.env.CLIENT_SITE_URL ||
+            'http://localhost:3001');
+    }
+    buildPreviewHtml(themeId, mods = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const manifest = this.getThemeManifestFromSources(themeId);
+        const name = (_a = manifest === null || manifest === void 0 ? void 0 : manifest.name) !== null && _a !== void 0 ? _a : themeId;
+        const primary = (_b = mods.primaryColor) !== null && _b !== void 0 ? _b : '#2271b1';
+        const accent = (_c = mods.accentColor) !== null && _c !== void 0 ? _c : '#d63638';
+        const bg = (_d = mods.backgroundColor) !== null && _d !== void 0 ? _d : '#f0f0f1';
+        const displayTitle = (_e = mods.displayTitle) !== null && _e !== void 0 ? _e : name;
+        const displayTagline = (_g = (_f = mods.displayTagline) !== null && _f !== void 0 ? _f : manifest === null || manifest === void 0 ? void 0 : manifest.description) !== null && _g !== void 0 ? _g : 'Theme preview';
+        const dark = mods.darkMode === '1' || mods.darkMode === 'true' || mods.darkMode === 'yes';
+        const textColor = dark ? '#e8e8e8' : '#1d2327';
+        const pageBg = dark ? '#1a1a1a' : bg;
+        const bgImage = (_h = mods.backgroundImage) === null || _h === void 0 ? void 0 : _h.trim();
+        const extraCss = (_k = (_j = mods.additionalCss) === null || _j === void 0 ? void 0 : _j.trim()) !== null && _k !== void 0 ? _k : '';
+        return `<!DOCTYPE html>
+<html lang="zh-CN"${dark ? ' data-rp-dark="true"' : ''}>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${displayTitle} — Preview</title>
+  <style>
+    :root {
+      --rp-primary: ${primary};
+      --rp-accent: ${accent};
+      --rp-bg: ${pageBg};
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: ${bgImage ? `url("${bgImage.replace(/"/g, '\\"')}") center/cover fixed` : 'var(--rp-bg)'};
+      color: ${textColor};
+      line-height: 1.6;
+    }
+    ${extraCss}
+    .wrap { max-width: 720px; margin: 0 auto; padding: 2rem 1.5rem 4rem; }
+    header { border-bottom: 3px solid var(--rp-primary); padding-bottom: 1rem; margin-bottom: 2rem; }
+    h1 { color: var(--rp-primary); font-size: 2rem; margin: 0 0 0.25rem; }
+    .tagline { color: #646970; margin: 0; }
+    h2 { color: var(--rp-accent); margin-top: 2rem; }
+    a { color: var(--rp-primary); }
+    .card {
+      background: #fff;
+      border: 1px solid #c3c4c7;
+      border-radius: 4px;
+      padding: 1.25rem;
+      margin-top: 1rem;
+    }
+    .meta { font-size: 0.875rem; color: #646970; }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <header>
+      <h1>${displayTitle}</h1>
+      <p class="tagline">${displayTagline}</p>
+    </header>
+    <h2>排版示例</h2>
+    <p>这是 <strong>${name}</strong> 主题的实时预览。在左侧自定义器中修改颜色与标题后，此页面会即时更新。</p>
+    <h3>标题层级</h3>
+    <h4>四级标题</h4>
+    <h5>五级标题</h5>
+    <h6>六级标题</h6>
+    <ul>
+      <li>无序列表项</li>
+      <li><a href="#">示例链接</a></li>
+    </ul>
+    <article class="card">
+      <h2 style="margin-top:0">Hello world!</h2>
+      <p class="meta">发布于 ${new Date().toLocaleDateString('zh-CN')}</p>
+      <p>欢迎使用 ReactPress 主题系统。激活主题后，访客站点将使用该主题的 Next.js 模板渲染。</p>
+    </article>
+  </div>
+</body>
+</html>`;
+    }
+    async getPreviewMods(themeId, overrideMods) {
+        var _a;
+        if (overrideMods && Object.keys(overrideMods).length > 0)
+            return overrideMods;
+        const state = await this.getThemeState();
+        return (_a = state.mods[themeId]) !== null && _a !== void 0 ? _a : {};
+    }
+    createPreviewDraft(payload) {
+        const token = (0, preview_draft_store_1.putPreviewDraft)(payload);
+        return { token };
+    }
+    resolvePreviewDraft(token) {
+        const draft = (0, preview_draft_store_1.getPreviewDraft)(token);
+        if (!draft)
+            return null;
+        return {
+            themeId: draft.themeId,
+            mods: draft.mods,
+            configuration: draft.configuration,
+        };
+    }
+    resolveFallbackActiveTheme(state) {
+        const candidates = [
+            state.activeTheme,
+            'hello-world',
+            ...state.installedThemes,
+            theme_2.defaultSiteThemeState.activeTheme,
+        ];
+        const seen = new Set();
+        for (const id of candidates) {
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            if (this.resolveThemeDir(id))
+                return id;
+        }
+        for (const manifest of this.listBundledThemes()) {
+            if (this.resolveThemeDir(manifest.id))
+                return manifest.id;
+        }
+        return null;
+    }
+    async ensureDefaultTheme() {
+        const state = await this.getThemeState();
+        let activeTheme = state.activeTheme;
+        if (!activeTheme || !this.resolveThemeDir(activeTheme)) {
+            const fallback = this.resolveFallbackActiveTheme(state);
+            if (fallback) {
+                const saved = await this.saveThemeState({
+                    activeTheme: fallback,
+                    previewThemeId: fallback,
+                    installedThemes: state.installedThemes.includes(fallback)
+                        ? state.installedThemes
+                        : [...state.installedThemes, fallback],
+                });
+                activeTheme = saved.activeTheme;
+            }
+            else if (!activeTheme) {
+                const saved = await this.saveThemeState(theme_2.defaultSiteThemeState);
+                activeTheme = saved.activeTheme;
+            }
+        }
+        if (this.resolveThemeDir(activeTheme)) {
+            this.syncActiveThemeManifest(activeTheme);
+        }
+    }
+    materializeRuntimeTheme(templatePath, targetDir) {
+        const forceCopy = process.env.REACTPRESS_THEME_RUNTIME_SYMLINK !== '1' &&
+            (process.env.REACTPRESS_THEME_RUNTIME_COPY === '1' || process.env.NODE_ENV === 'production');
+        if (!forceCopy) {
+            const linkTarget = path.relative(path.dirname(targetDir), templatePath);
+            fs.symlinkSync(linkTarget, targetDir, 'dir');
+            return;
+        }
+        this.copyDir(templatePath, targetDir);
+        this.linkTemplateNodeModules(templatePath, targetDir);
+    }
+    copyDir(src, dest) {
+        fs.mkdirSync(dest, { recursive: true });
+        for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+            if (ThemeService_1.COPY_SKIP_NAMES.has(entry.name))
+                continue;
+            const from = path.join(src, entry.name);
+            const to = path.join(dest, entry.name);
+            if (entry.isSymbolicLink()) {
+                const link = fs.readlinkSync(from);
+                fs.symlinkSync(link, to);
+            }
+            else if (entry.isDirectory()) {
+                this.copyDir(from, to);
+            }
+            else if (entry.isFile()) {
+                fs.copyFileSync(from, to);
+            }
+        }
+    }
+    linkTemplateNodeModules(templatePath, targetDir) {
+        const srcModules = path.join(templatePath, 'node_modules');
+        const destModules = path.join(targetDir, 'node_modules');
+        if (!fs.existsSync(srcModules) || fs.existsSync(destModules))
+            return;
+        const linkTarget = path.relative(targetDir, srcModules);
+        const linkType = fs.lstatSync(srcModules).isDirectory() ? 'dir' : 'file';
+        fs.symlinkSync(linkTarget, destModules, linkType);
+    }
+    removeDir(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const stat = fs.lstatSync(dir);
+        if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            fs.unlinkSync(dir);
+            return;
+        }
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const target = path.join(dir, entry.name);
+            if (entry.isSymbolicLink()) {
+                fs.unlinkSync(target);
+            }
+            else if (entry.isDirectory()) {
+                this.removeDir(target);
+            }
+            else {
+                fs.unlinkSync(target);
+            }
+        }
+        fs.rmdirSync(dir);
+    }
+};
+ThemeService.COPY_SKIP_NAMES = new Set([
+    'node_modules',
+    '.next',
+    '.git',
+    'dist',
+    '.turbo',
+    'coverage',
+    '.reactpress',
+    '.cache',
+    'package-lock.json',
+]);
+ThemeService = ThemeService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(setting_entity_1.Setting)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        setting_service_1.SettingService])
+], ThemeService);
+exports.ThemeService = ThemeService;
+//# sourceMappingURL=theme.service.js.map