@deneb-ui/core 2.0.24

package/dist/fonts/installProject.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FONTS_CSS_IMPORT = exports.FONTS_CSS_REL = exports.FONTS_MANIFEST_REL = void 0;
+exports.findSiteDataPath = findSiteDataPath;
+exports.findHostProject = findHostProject;
+exports.generateFontsCss = generateFontsCss;
+exports.installProjectFonts = installProjectFonts;
+exports.installFontsForHostOf = installFontsForHostOf;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const registry_1 = require("./registry");
+const resolve_1 = require("./resolve");
+exports.FONTS_MANIFEST_REL = '.deneb/fonts.json';
+exports.FONTS_CSS_REL = 'src/fonts/deneb-fonts.css';
+exports.FONTS_CSS_IMPORT = './fonts/deneb-fonts.css';
+const SKIP_HOST_NAMES = new Set([
+    '@deneb-ui/ui',
+    '@deneb-ui/core',
+    '@deneb-ui/cli',
+    '@deneb-ui/create-template',
+    'deneb-ui-framework-monorepo',
+]);
+function log(quiet, message) {
+    if (!quiet)
+        console.log(message);
+}
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function findSiteDataPath(projectDir) {
+    const candidates = [
+        node_path_1.default.join(projectDir, 'src', 'data', 'site-data.json'),
+        node_path_1.default.join(projectDir, 'site-data.json'),
+        node_path_1.default.join(projectDir, 'data', 'site-data.json'),
+    ];
+    return candidates.find((candidate) => node_fs_1.default.existsSync(candidate)) ?? null;
+}
+function findHostProject(startDir) {
+    let dir = node_path_1.default.resolve(startDir);
+    for (let i = 0; i < 12; i++) {
+        const pkgPath = node_path_1.default.join(dir, 'package.json');
+        if (node_fs_1.default.existsSync(pkgPath)) {
+            const pkg = readJsonSafe(pkgPath);
+            const name = typeof pkg?.name === 'string' ? pkg.name : '';
+            if (!SKIP_HOST_NAMES.has(name)) {
+                const deps = {
+                    ...(pkg?.dependencies ?? {}),
+                    ...(pkg?.devDependencies ?? {}),
+                };
+                if (deps['@deneb-ui/ui'] || deps.next || deps.react) {
+                    return dir;
+                }
+            }
+        }
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function detectPackageManager(projectDir) {
+    if (node_fs_1.default.existsSync(node_path_1.default.join(projectDir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (node_fs_1.default.existsSync(node_path_1.default.join(projectDir, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function buildFontsourceCssEntries(font) {
+    const pkg = font.fontsourcePackage;
+    if (!pkg)
+        return [];
+    if (font.variable) {
+        return [`@import '@fontsource/${pkg}/index.css';`];
+    }
+    const weights = font.weights.length > 0 ? font.weights : [400];
+    const lines = [];
+    for (const weight of weights) {
+        lines.push(`@import '@fontsource/${pkg}/${weight}.css';`);
+        if (font.italic) {
+            lines.push(`@import '@fontsource/${pkg}/${weight}-italic.css';`);
+        }
+    }
+    return lines;
+}
+function generateFontsCss(fonts) {
+    const lines = [
+        '/*',
+        ' * DENEB Fonts — self-hosted via @fontsource',
+        ' * Generated by: deneb fonts install / @deneb-ui/ui postinstall',
+        ' */',
+        '',
+        ':root { --deneb-fonts-selfhosted: 1; }',
+        '',
+    ];
+    for (const font of fonts) {
+        lines.push(`/* ${font.label} (${font.id}) */`);
+        lines.push(...buildFontsourceCssEntries(font));
+        lines.push('');
+    }
+    return `${lines.join('\n').trim()}\n`;
+}
+function patchLayoutImport(projectDir) {
+    const layoutCandidates = [
+        node_path_1.default.join(projectDir, 'src', 'app', 'layout.tsx'),
+        node_path_1.default.join(projectDir, 'src', 'app', 'layout.jsx'),
+        node_path_1.default.join(projectDir, 'app', 'layout.tsx'),
+        node_path_1.default.join(projectDir, 'app', 'layout.jsx'),
+    ];
+    const layoutPath = layoutCandidates.find((candidate) => node_fs_1.default.existsSync(candidate));
+    if (!layoutPath)
+        return { patched: false, reason: 'layout.tsx not found' };
+    let source = node_fs_1.default.readFileSync(layoutPath, 'utf8');
+    if (source.includes(exports.FONTS_CSS_IMPORT) || source.includes('deneb-fonts.css')) {
+        return { patched: false, reason: 'already imported', layoutPath };
+    }
+    const importLine = `import '${exports.FONTS_CSS_IMPORT}';`;
+    if (source.includes("import './globals.css'")) {
+        source = source.replace("import './globals.css';", `import './globals.css';\n${importLine}`);
+    }
+    else if (source.includes('import "./globals.css"')) {
+        source = source.replace('import "./globals.css";', `import "./globals.css";\n${importLine}`);
+    }
+    else {
+        source = `${importLine}\n${source}`;
+    }
+    node_fs_1.default.writeFileSync(layoutPath, source, 'utf8');
+    return { patched: true, reason: 'patched', layoutPath };
+}
+function resolveInstallableList(projectDir, options) {
+    const warnings = [];
+    const ids = new Set();
+    if (options.all) {
+        for (const font of registry_1.DENEB_FONT_REGISTRY) {
+            if (font.fontsourcePackage)
+                ids.add(font.id);
+        }
+    }
+    else if (options.fontIds && options.fontIds.length > 0) {
+        for (const id of options.fontIds)
+            ids.add((0, resolve_1.normalizeFontId)(id));
+    }
+    else {
+        const siteDataPath = findSiteDataPath(projectDir);
+        if (siteDataPath) {
+            const siteData = readJsonSafe(siteDataPath) ?? {};
+            for (const id of (0, resolve_1.collectFontIdsFromSiteData)(siteData))
+                ids.add(id);
+        }
+        if (ids.size === 0) {
+            for (const id of registry_1.DEFAULT_PROJECT_FONT_IDS)
+                ids.add(id);
+        }
+    }
+    const fonts = [];
+    for (const id of ids) {
+        const font = (0, resolve_1.resolveInstallableFont)(id) ?? (0, resolve_1.lookupFontDefinition)(id);
+        if (!font?.fontsourcePackage) {
+            warnings.push(`Skipped "${id}" — not available on Google Fonts / @fontsource`);
+            continue;
+        }
+        if (!fonts.find((entry) => entry.id === font.id))
+            fonts.push(font);
+    }
+    return { fonts, warnings };
+}
+function packagesAlreadyPresent(projectDir, packages) {
+    const pkg = readJsonSafe(node_path_1.default.join(projectDir, 'package.json'));
+    const deps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+    };
+    return packages.every((name) => Boolean(deps[name]));
+}
+function installPackages(projectDir, packages, quiet) {
+    if (packages.length === 0)
+        return;
+    if (packagesAlreadyPresent(projectDir, packages))
+        return;
+    const pm = detectPackageManager(projectDir);
+    const args = pm === 'pnpm'
+        ? ['add', ...packages]
+        : pm === 'yarn'
+            ? ['add', ...packages]
+            : ['install', ...packages, '--save'];
+    const res = (0, node_child_process_1.spawnSync)(pm, args, {
+        cwd: projectDir,
+        stdio: quiet ? 'pipe' : 'inherit',
+        shell: true,
+        env: { ...process.env, DENEB_SKIP_FONTS: '1' },
+    });
+    if (res.status !== 0) {
+        throw new Error(`${pm} install failed for font packages`);
+    }
+}
+function installProjectFonts(options) {
+    const projectDir = node_path_1.default.resolve(options.projectDir);
+    const warnings = [];
+    if (process.env.DENEB_SKIP_FONTS === '1') {
+        return { ok: true, skipped: 'DENEB_SKIP_FONTS=1', installed: [], packages: [], warnings };
+    }
+    if (!node_fs_1.default.existsSync(projectDir)) {
+        return { ok: false, skipped: 'directory not found', installed: [], packages: [], warnings };
+    }
+    const { fonts, warnings: resolveWarnings } = resolveInstallableList(projectDir, options);
+    warnings.push(...resolveWarnings);
+    if (fonts.length === 0) {
+        return { ok: false, installed: [], packages: [], warnings };
+    }
+    const packages = fonts.map((font) => `@fontsource/${font.fontsourcePackage}`);
+    log(options.quiet, `\nInstalling ${fonts.length} DENEB font package(s) into ${projectDir}\n`);
+    installPackages(projectDir, packages, options.quiet);
+    const cssPath = node_path_1.default.join(projectDir, exports.FONTS_CSS_REL);
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(cssPath), { recursive: true });
+    node_fs_1.default.writeFileSync(cssPath, generateFontsCss(fonts), 'utf8');
+    const manifestPath = node_path_1.default.join(projectDir, exports.FONTS_MANIFEST_REL);
+    const manifest = {
+        version: 1,
+        installedAt: new Date().toISOString(),
+        fonts: fonts.map((font) => ({
+            id: font.id,
+            fontsourcePackage: font.fontsourcePackage,
+            weights: font.weights,
+            variable: font.variable,
+        })),
+    };
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(manifestPath), { recursive: true });
+    node_fs_1.default.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    const layout = patchLayoutImport(projectDir);
+    if (!options.quiet) {
+        for (const warning of warnings)
+            console.warn(`⚠ ${warning}`);
+        console.log(`✔ Wrote ${exports.FONTS_CSS_REL}`);
+        console.log(`✔ Wrote ${exports.FONTS_MANIFEST_REL}`);
+        if (layout.patched) {
+            console.log(`✔ Patched layout font import`);
+        }
+        else {
+            console.log(`ℹ Add to layout: import '${exports.FONTS_CSS_IMPORT}'; (${layout.reason})`);
+        }
+    }
+    return {
+        ok: true,
+        installed: fonts.map((font) => font.id),
+        packages,
+        cssPath,
+        manifestPath,
+        layoutPatched: layout.patched,
+        warnings,
+    };
+}
+function installFontsForHostOf(packageDir) {
+    const host = findHostProject(packageDir);
+    if (!host) {
+        return {
+            ok: true,
+            skipped: 'no host Next/React app found',
+            installed: [],
+            packages: [],
+            warnings: [],
+        };
+    }
+    return installProjectFonts({ projectDir: host, quiet: true });
+}

package/dist/fonts/registry.d.ts

@@ -0,0 +1,7 @@
+import type { DenebFontDefinition } from './types';
+/** Curated catalog — 54 web-friendly faces from [Google Fonts](https://fonts.google.com/) */
+export declare const DENEB_FONT_REGISTRY: DenebFontDefinition[];
+export declare const DENEB_FONT_BY_ID: Map<string, DenebFontDefinition>;
+export declare const DENEB_GOOGLE_FONT_COUNT: number;
+/** Default self-hosted set when a project has no site-data font choices yet. */
+export declare const DEFAULT_PROJECT_FONT_IDS: readonly ["inter", "plus-jakarta-sans", "playfair-display"];

package/dist/fonts/registry.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROJECT_FONT_IDS = exports.DENEB_GOOGLE_FONT_COUNT = exports.DENEB_FONT_BY_ID = exports.DENEB_FONT_REGISTRY = void 0;
+const W = [400, 500, 600, 700];
+const W_DISPLAY = [400, 700];
+const W_MONO = [400, 500, 600, 700];
+function googleFont(id, label, category, fontsourcePackage, googleQuery, options) {
+    const family = label;
+    return {
+        id,
+        label,
+        category,
+        family,
+        cssStack: options?.cssStack ?? `'${family}', ${category === 'serif' || category === 'slab-serif' ? 'Georgia, serif' : category === 'monospace' ? 'ui-monospace, monospace' : 'system-ui, sans-serif'}`,
+        fontsourcePackage,
+        googleQuery,
+        googleFonts: true,
+        weights: options?.weights ?? W,
+        italic: options?.italic,
+        variable: options?.variable,
+    };
+}
+/** Curated catalog — 54 web-friendly faces from [Google Fonts](https://fonts.google.com/) */
+exports.DENEB_FONT_REGISTRY = [
+    // ── Sans-serif ──
+    googleFont('inter', 'Inter', 'sans-serif', 'inter', 'Inter', { variable: true }),
+    googleFont('roboto', 'Roboto', 'sans-serif', 'roboto', 'Roboto'),
+    googleFont('open-sans', 'Open Sans', 'sans-serif', 'open-sans', 'Open+Sans', { variable: true }),
+    googleFont('lato', 'Lato', 'sans-serif', 'lato', 'Lato', { italic: true }),
+    googleFont('montserrat', 'Montserrat', 'sans-serif', 'montserrat', 'Montserrat', { variable: true }),
+    googleFont('poppins', 'Poppins', 'sans-serif', 'poppins', 'Poppins'),
+    googleFont('nunito', 'Nunito', 'sans-serif', 'nunito', 'Nunito', { variable: true }),
+    googleFont('raleway', 'Raleway', 'sans-serif', 'raleway', 'Raleway', { variable: true }),
+    googleFont('dm-sans', 'DM Sans', 'sans-serif', 'dm-sans', 'DM+Sans', { variable: true }),
+    googleFont('work-sans', 'Work Sans', 'sans-serif', 'work-sans', 'Work+Sans', { variable: true }),
+    googleFont('fira-sans', 'Fira Sans', 'sans-serif', 'fira-sans', 'Fira+Sans'),
+    googleFont('manrope', 'Manrope', 'sans-serif', 'manrope', 'Manrope', { variable: true }),
+    googleFont('oswald', 'Oswald', 'sans-serif', 'oswald', 'Oswald', { weights: [400, 500, 600, 700] }),
+    googleFont('source-sans-3', 'Source Sans 3', 'sans-serif', 'source-sans-3', 'Source+Sans+3', { variable: true }),
+    googleFont('quicksand', 'Quicksand', 'sans-serif', 'quicksand', 'Quicksand', { variable: true }),
+    googleFont('plus-jakarta-sans', 'Plus Jakarta Sans', 'sans-serif', 'plus-jakarta-sans', 'Plus+Jakarta+Sans', { variable: true }),
+    {
+        id: 'satoshi',
+        label: 'Satoshi',
+        category: 'sans-serif',
+        family: 'Space Grotesk',
+        cssStack: "'Space Grotesk', system-ui, sans-serif",
+        fontsourcePackage: null,
+        googleQuery: null,
+        googleFonts: false,
+        weights: W,
+        substituteId: 'space-grotesk',
+    },
+    googleFont('space-grotesk', 'Space Grotesk', 'sans-serif', 'space-grotesk', 'Space+Grotesk', { variable: true }),
+    googleFont('figtree', 'Figtree', 'sans-serif', 'figtree', 'Figtree', { variable: true }),
+    googleFont('urbanist', 'Urbanist', 'sans-serif', 'urbanist', 'Urbanist', { variable: true }),
+    googleFont('outfit', 'Outfit', 'sans-serif', 'outfit', 'Outfit', { variable: true }),
+    {
+        id: 'general-sans',
+        label: 'General Sans',
+        category: 'sans-serif',
+        family: 'Figtree',
+        cssStack: "'Figtree', system-ui, sans-serif",
+        fontsourcePackage: null,
+        googleQuery: null,
+        googleFonts: false,
+        weights: W,
+        substituteId: 'figtree',
+    },
+    googleFont('mulish', 'Mulish', 'sans-serif', 'mulish', 'Mulish', { variable: true }),
+    googleFont('barlow', 'Barlow', 'sans-serif', 'barlow', 'Barlow'),
+    googleFont('rubik', 'Rubik', 'sans-serif', 'rubik', 'Rubik', { variable: true }),
+    googleFont('geist', 'Geist', 'sans-serif', 'geist-sans', 'Geist', { variable: true }),
+    // ── Serif ──
+    googleFont('merriweather', 'Merriweather', 'serif', 'merriweather', 'Merriweather'),
+    googleFont('playfair-display', 'Playfair Display', 'serif', 'playfair-display', 'Playfair+Display'),
+    googleFont('lora', 'Lora', 'serif', 'lora', 'Lora', { variable: true }),
+    googleFont('pt-serif', 'PT Serif', 'serif', 'pt-serif', 'PT+Serif'),
+    googleFont('eb-garamond', 'EB Garamond', 'serif', 'eb-garamond', 'EB+Garamond', { variable: true }),
+    googleFont('libre-baskerville', 'Libre Baskerville', 'serif', 'libre-baskerville', 'Libre+Baskerville'),
+    googleFont('crimson-text', 'Crimson Text', 'serif', 'crimson-text', 'Crimson+Text'),
+    googleFont('cormorant-garamond', 'Cormorant Garamond', 'serif', 'cormorant-garamond', 'Cormorant+Garamond'),
+    googleFont('frank-ruhl-libre', 'Frank Ruhl Libre', 'serif', 'frank-ruhl-libre', 'Frank+Ruhl+Libre'),
+    googleFont('taviraj', 'Taviraj', 'serif', 'taviraj', 'Taviraj'),
+    googleFont('arapey', 'Arapey', 'serif', 'arapey', 'Arapey', { weights: [400], italic: true }),
+    googleFont('caladea', 'Caladea', 'serif', 'caladea', 'Caladea'),
+    // ── Slab serif ──
+    googleFont('roboto-slab', 'Roboto Slab', 'slab-serif', 'roboto-slab', 'Roboto+Slab', { variable: true }),
+    googleFont('zilla-slab', 'Zilla Slab', 'slab-serif', 'zilla-slab', 'Zilla+Slab'),
+    googleFont('aleo', 'Aleo', 'slab-serif', 'aleo', 'Aleo', { variable: true }),
+    googleFont('arvo', 'Arvo', 'slab-serif', 'arvo', 'Arvo'),
+    googleFont('bitter', 'Bitter', 'slab-serif', 'bitter', 'Bitter', { variable: true }),
+    googleFont('enriqueta', 'Enriqueta', 'slab-serif', 'enriqueta', 'Enriqueta'),
+    // ── Monospace ──
+    googleFont('fira-code', 'Fira Code', 'monospace', 'fira-code', 'Fira+Code', { weights: W_MONO, variable: true }),
+    googleFont('roboto-mono', 'Roboto Mono', 'monospace', 'roboto-mono', 'Roboto+Mono', { weights: W_MONO, variable: true }),
+    googleFont('jetbrains-mono', 'JetBrains Mono', 'monospace', 'jetbrains-mono', 'JetBrains+Mono', { weights: W_MONO, variable: true }),
+    googleFont('space-mono', 'Space Mono', 'monospace', 'space-mono', 'Space+Mono', { weights: [400, 700], italic: true }),
+    // ── Display ──
+    googleFont('bebas-neue', 'Bebas Neue', 'display', 'bebas-neue', 'Bebas+Neue', { weights: [400] }),
+    googleFont('fraunces', 'Fraunces', 'display', 'fraunces', 'Fraunces', { variable: true }),
+    googleFont('cinzel', 'Cinzel', 'display', 'cinzel', 'Cinzel', { weights: W_DISPLAY }),
+    googleFont('paytone-one', 'Paytone One', 'display', 'paytone-one', 'Paytone+One', { weights: [400] }),
+    googleFont('righteous', 'Righteous', 'display', 'righteous', 'Righteous', { weights: [400] }),
+    googleFont('abril-fatface', 'Abril Fatface', 'display', 'abril-fatface', 'Abril+Fatface', { weights: [400] }),
+    // ── System / editorial aliases ──
+    {
+        id: 'system-sans',
+        label: 'System Sans',
+        category: 'system',
+        family: 'system-ui',
+        cssStack: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+        fontsourcePackage: null,
+        googleQuery: null,
+        googleFonts: false,
+        weights: [],
+    },
+    {
+        id: 'editorial-serif',
+        label: 'Editorial Serif',
+        category: 'serif',
+        family: 'Playfair Display',
+        cssStack: "'Playfair Display', Georgia, serif",
+        fontsourcePackage: 'playfair-display',
+        googleQuery: 'Playfair+Display',
+        googleFonts: true,
+        weights: W,
+        substituteId: 'playfair-display',
+    },
+];
+exports.DENEB_FONT_BY_ID = new Map(exports.DENEB_FONT_REGISTRY.map((font) => [font.id, font]));
+exports.DENEB_GOOGLE_FONT_COUNT = exports.DENEB_FONT_REGISTRY.filter((f) => f.googleFonts && f.fontsourcePackage).length;
+/** Default self-hosted set when a project has no site-data font choices yet. */
+exports.DEFAULT_PROJECT_FONT_IDS = [
+    'inter',
+    'plus-jakarta-sans',
+    'playfair-display',
+];

package/dist/fonts/resolve.d.ts

@@ -0,0 +1,7 @@
+import type { DenebFontDefinition } from './types';
+export declare function normalizeFontId(value: string): string;
+export declare function lookupFontDefinition(value: string | undefined): DenebFontDefinition | null;
+export declare function resolveInstallableFont(value: string | undefined): DenebFontDefinition | null;
+export declare function resolveFontFamily(value: string | undefined): string | undefined;
+export declare function listFontsByCategory(): Record<string, DenebFontDefinition[]>;
+export declare function collectFontIdsFromSiteData(siteData: unknown): string[];

package/dist/fonts/resolve.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFontId = normalizeFontId;
+exports.lookupFontDefinition = lookupFontDefinition;
+exports.resolveInstallableFont = resolveInstallableFont;
+exports.resolveFontFamily = resolveFontFamily;
+exports.listFontsByCategory = listFontsByCategory;
+exports.collectFontIdsFromSiteData = collectFontIdsFromSiteData;
+const registry_1 = require("./registry");
+function normalizeFontId(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/['"]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+}
+function lookupFontDefinition(value) {
+    if (!value || !value.trim())
+        return null;
+    const slug = normalizeFontId(value);
+    const direct = registry_1.DENEB_FONT_BY_ID.get(slug);
+    if (direct)
+        return direct;
+    for (const font of registry_1.DENEB_FONT_REGISTRY) {
+        if (normalizeFontId(font.label) === slug)
+            return font;
+        if (normalizeFontId(font.family) === slug)
+            return font;
+    }
+    // Match partial family from css stack input e.g. "Inter, sans-serif"
+    const primary = value.split(',')[0]?.trim().replace(/^['"]|['"]$/g, '');
+    if (primary) {
+        const primarySlug = normalizeFontId(primary);
+        return registry_1.DENEB_FONT_BY_ID.get(primarySlug) ?? lookupFontDefinition(primarySlug);
+    }
+    return null;
+}
+function resolveInstallableFont(value) {
+    const font = lookupFontDefinition(value);
+    if (!font)
+        return null;
+    if (font.fontsourcePackage)
+        return font;
+    if (font.substituteId)
+        return registry_1.DENEB_FONT_BY_ID.get(font.substituteId) ?? null;
+    return null;
+}
+function resolveFontFamily(value) {
+    if (!value || !value.trim())
+        return undefined;
+    const font = lookupFontDefinition(value);
+    if (font)
+        return font.cssStack;
+    // Pass through quoted stacks or raw family names
+    if (value.includes(','))
+        return value;
+    return `'${value.trim()}', system-ui, sans-serif`;
+}
+function listFontsByCategory() {
+    var _a;
+    const grouped = {};
+    for (const font of registry_1.DENEB_FONT_REGISTRY) {
+        grouped[_a = font.category] ?? (grouped[_a] = []);
+        grouped[font.category].push(font);
+    }
+    return grouped;
+}
+function collectFontIdsFromSiteData(siteData) {
+    const ids = new Set();
+    const add = (raw) => {
+        if (typeof raw !== 'string' || !raw.trim())
+            return;
+        const font = lookupFontDefinition(raw);
+        if (font) {
+            ids.add(font.id);
+            if (font.substituteId)
+                ids.add(font.substituteId);
+            return;
+        }
+        const slug = normalizeFontId(raw);
+        if (slug)
+            ids.add(slug);
+    };
+    if (!siteData || typeof siteData !== 'object')
+        return [];
+    const data = siteData;
+    const theme = data.theme ??
+        data.template?.structure?.theme;
+    add(theme?.headingFont);
+    add(theme?.bodyFont);
+    const styles = data.styles;
+    if (styles && typeof styles === 'object' && !Array.isArray(styles)) {
+        for (const styleEntry of Object.values(styles)) {
+            if (styleEntry && typeof styleEntry === 'object' && !Array.isArray(styleEntry)) {
+                add(styleEntry.fontFamily);
+            }
+        }
+    }
+    const walkContent = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (Array.isArray(node)) {
+            node.forEach(walkContent);
+            return;
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (key.endsWith('Style') && value && typeof value === 'object') {
+                add(value.fontFamily);
+            }
+            walkContent(value);
+        }
+    };
+    walkContent(data.content);
+    ids.delete('system-sans');
+    return Array.from(ids);
+}

package/dist/fonts/types.d.ts

@@ -0,0 +1,36 @@
+export type DenebFontCategory = 'sans-serif' | 'serif' | 'slab-serif' | 'monospace' | 'display' | 'system';
+export interface DenebFontDefinition {
+    /** Stable slug for Fivora + site-data (e.g. `plus-jakarta-sans`) */
+    id: string;
+    /** Human label shown in editors */
+    label: string;
+    category: DenebFontCategory;
+    /** Primary CSS family name */
+    family: string;
+    /** Full CSS font-family stack */
+    cssStack: string;
+    /** @fontsource package name (without scope), null when not installable */
+    fontsourcePackage: string | null;
+    /** Google Fonts API family query segment */
+    googleQuery: string | null;
+    /** Whether this font is served from Google Fonts */
+    googleFonts: boolean;
+    /** Default weights to install / load */
+    weights: number[];
+    /** Include italic axis in Google Fonts request */
+    italic?: boolean;
+    /** Use variable font bundle when installing via @fontsource */
+    variable?: boolean;
+    /** When not on Google Fonts, maps to this registry id for install/load */
+    substituteId?: string;
+}
+export interface DenebFontManifest {
+    version: 1;
+    installedAt: string;
+    fonts: Array<{
+        id: string;
+        fontsourcePackage: string;
+        weights: number[];
+        variable?: boolean;
+    }>;
+}

package/dist/fonts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './fonts';
+export * from './types/styles';
+export * from './types/protocol';
+export * from './types/markers';
+export * from './engine/cssVariables';
+export * from './engine/domPatcher';
+export * from './engine/tokenResolver';
+export * from './engine/deepMerge';
+export * from './validation/styleSchemaValidator';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fonts"), exports);
+__exportStar(require("./types/styles"), exports);
+__exportStar(require("./types/protocol"), exports);
+__exportStar(require("./types/markers"), exports);
+__exportStar(require("./engine/cssVariables"), exports);
+__exportStar(require("./engine/domPatcher"), exports);
+__exportStar(require("./engine/tokenResolver"), exports);
+__exportStar(require("./engine/deepMerge"), exports);
+__exportStar(require("./validation/styleSchemaValidator"), exports);

package/dist/types/markers.d.ts

@@ -0,0 +1,7 @@
+export declare const STYLE_TARGET_ATTRIBUTE = "data-preview-style-target";
+export declare const STYLE_TYPE_ATTRIBUTE = "data-preview-style-type";
+export declare const PREVIEW_FIELD_ATTRIBUTE = "data-preview-field-path";
+export declare const PREVIEW_ITEM_ATTRIBUTE = "data-preview-item-path";
+export declare const PREVIEW_LIST_ATTRIBUTE = "data-preview-list-path";
+export declare function buildStyleTargetSelector(targetPath: string): string;
+export declare function buildStyleFallbackSelectors(targetPath: string, styleType?: string): string[];

package/dist/types/markers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREVIEW_LIST_ATTRIBUTE = exports.PREVIEW_ITEM_ATTRIBUTE = exports.PREVIEW_FIELD_ATTRIBUTE = exports.STYLE_TYPE_ATTRIBUTE = exports.STYLE_TARGET_ATTRIBUTE = void 0;
+exports.buildStyleTargetSelector = buildStyleTargetSelector;
+exports.buildStyleFallbackSelectors = buildStyleFallbackSelectors;
+exports.STYLE_TARGET_ATTRIBUTE = 'data-preview-style-target';
+exports.STYLE_TYPE_ATTRIBUTE = 'data-preview-style-type';
+exports.PREVIEW_FIELD_ATTRIBUTE = 'data-preview-field-path';
+exports.PREVIEW_ITEM_ATTRIBUTE = 'data-preview-item-path';
+exports.PREVIEW_LIST_ATTRIBUTE = 'data-preview-list-path';
+function escapeAttributeValue(value) {
+    if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {
+        return CSS.escape(value);
+    }
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function buildStyleTargetSelector(targetPath) {
+    return `[${exports.STYLE_TARGET_ATTRIBUTE}="${escapeAttributeValue(targetPath)}"]`;
+}
+function buildStyleFallbackSelectors(targetPath, styleType) {
+    const selectors = [
+        buildStyleTargetSelector(targetPath),
+        `[${exports.PREVIEW_FIELD_ATTRIBUTE}="${escapeAttributeValue(targetPath)}"]`,
+        `[${exports.PREVIEW_ITEM_ATTRIBUTE}="${escapeAttributeValue(targetPath)}"]`,
+    ];
+    if (styleType === 'card' && targetPath.endsWith('.card')) {
+        const itemPath = targetPath.slice(0, -'.card'.length);
+        selectors.push(`[${exports.PREVIEW_ITEM_ATTRIBUTE}="${escapeAttributeValue(itemPath)}"]`);
+    }
+    return selectors;
+}