@spacefast/common 0.0.9 → 0.0.10

package/dist/utils/gate-theme.js

@@ -1,217 +0,0 @@
-import { sfThemeJsoncSchema } from "../contracts/space-config.js";
-import { themeJsonSchema } from "../contracts/theme-json.js";
-import { stripJsonComments } from "./space-config.js";
-import { isSafeThemeColor, isSafeThemeFontFamily } from "./space-theme.js";
-/** Bound on the raw `theme.json` / `sf.theme.jsonc` file size at finalize. */
-export const GATE_THEME_FILE_MAX_BYTES = 64 * 1024;
-/** Bound on the compiled additive CSS custom-property block. */
-export const GATE_THEME_VARS_MAX_BYTES = 8 * 1024;
-/**
- * Parses a `theme.json` file's `settings.color.palette` /
- * `settings.typography.fontFamilies` into gate-page tokens (accent/background
- * derived from conventionally-named slugs: `accent`|`primary`, `background`)
- * plus a full CSS custom-property block for every safe palette/font-family
- * entry. Any problem (oversized, invalid JSON, invalid shape) warns and
- * yields an empty result — the next tier down still applies.
- */
-export function parseThemeJsonFile(raw) {
-    const empty = { theme: {}, themeVars: null, diagnostics: [] };
-    if (Buffer.byteLength(raw) > GATE_THEME_FILE_MAX_BYTES) {
-        return {
-            ...empty,
-            diagnostics: [
-                {
-                    severity: "warning",
-                    code: "theme_json_too_large",
-                    message: `theme.json exceeds the ${GATE_THEME_FILE_MAX_BYTES} byte limit and was ignored.`,
-                    path: "theme.json",
-                },
-            ],
-        };
-    }
-    let candidate;
-    try {
-        candidate = JSON.parse(raw);
-    }
-    catch (error) {
-        return {
-            ...empty,
-            diagnostics: [
-                {
-                    severity: "warning",
-                    code: "theme_json_invalid",
-                    message: `theme.json is not valid JSON: ${error instanceof Error ? error.message : "parse error"}.`,
-                    path: "theme.json",
-                },
-            ],
-        };
-    }
-    const parsed = themeJsonSchema.safeParse(candidate);
-    if (!parsed.success) {
-        return {
-            ...empty,
-            diagnostics: [
-                {
-                    severity: "warning",
-                    code: "theme_json_invalid",
-                    message: "theme.json does not match the supported settings.color.palette/settings.typography.fontFamilies shape.",
-                    path: "theme.json",
-                },
-            ],
-        };
-    }
-    const diagnostics = [];
-    const declarations = [];
-    const theme = {};
-    const palette = parsed.data.settings?.color?.palette ?? [];
-    for (const entry of palette) {
-        if (!isSafeThemeColor(entry.color)) {
-            diagnostics.push({
-                severity: "warning",
-                code: "theme_json_value_invalid",
-                message: `theme.json settings.color.palette[slug=${entry.slug}] is not a safe color and was dropped.`,
-                path: `theme.json:settings.color.palette.${entry.slug}`,
-            });
-            continue;
-        }
-        declarations.push(`--wp--preset--color--${entry.slug}:${entry.color.trim()}`);
-        if (entry.slug === "accent" || entry.slug === "primary") {
-            theme.accent ??= entry.color.trim();
-        }
-        if (entry.slug === "background") {
-            theme.background = entry.color.trim();
-        }
-    }
-    const fontFamilies = parsed.data.settings?.typography?.fontFamilies ?? [];
-    fontFamilies.forEach((entry, index) => {
-        if (!isSafeThemeFontFamily(entry.fontFamily)) {
-            diagnostics.push({
-                severity: "warning",
-                code: "theme_json_value_invalid",
-                message: `theme.json settings.typography.fontFamilies[slug=${entry.slug}] is not a safe font-family stack and was dropped.`,
-                path: `theme.json:settings.typography.fontFamilies.${entry.slug}`,
-            });
-            return;
-        }
-        declarations.push(`--wp--preset--font-family--${entry.slug}:${entry.fontFamily.trim()}`);
-        if (index === 0) {
-            theme.fontFamily ??= entry.fontFamily.trim();
-        }
-    });
-    let themeVars = declarations.join(";");
-    while (Buffer.byteLength(themeVars) > GATE_THEME_VARS_MAX_BYTES && declarations.length > 0) {
-        declarations.pop();
-        diagnostics.push({
-            severity: "warning",
-            code: "theme_json_value_invalid",
-            message: `theme.json compiled CSS exceeds ${GATE_THEME_VARS_MAX_BYTES} bytes; trailing tokens were dropped.`,
-            path: "theme.json",
-        });
-        themeVars = declarations.join(";");
-    }
-    return {
-        theme,
-        themeVars: themeVars.length > 0 ? themeVars : null,
-        diagnostics,
-    };
-}
-/**
- * Parses the `sf.theme.jsonc` escape hatch: same JSONC tolerance and the same
- * validated token grammar as `spacefast.jsonc "pages.theme"`
- * (`spacePagesThemeSchema`), just from a dedicated file. Any problem warns
- * and yields an empty result.
- */
-export function parseSfThemeJsonc(raw) {
-    if (Buffer.byteLength(raw) > GATE_THEME_FILE_MAX_BYTES) {
-        return {
-            theme: {},
-            diagnostics: [
-                {
-                    severity: "warning",
-                    code: "sf_theme_jsonc_too_large",
-                    message: `sf.theme.jsonc exceeds the ${GATE_THEME_FILE_MAX_BYTES} byte limit and was ignored.`,
-                    path: "sf.theme.jsonc",
-                },
-            ],
-        };
-    }
-    let candidate;
-    try {
-        candidate = JSON.parse(stripJsonComments(raw));
-    }
-    catch (error) {
-        return {
-            theme: {},
-            diagnostics: [
-                {
-                    severity: "warning",
-                    code: "sf_theme_jsonc_invalid",
-                    message: `sf.theme.jsonc is not valid JSONC: ${error instanceof Error ? error.message : "parse error"}.`,
-                    path: "sf.theme.jsonc",
-                },
-            ],
-        };
-    }
-    const parsed = sfThemeJsoncSchema.safeParse(candidate);
-    if (!parsed.success) {
-        return {
-            theme: {},
-            diagnostics: [
-                {
-                    severity: "warning",
-                    code: "sf_theme_jsonc_invalid",
-                    message: "sf.theme.jsonc does not match the gate-page theme token shape.",
-                    path: "sf.theme.jsonc",
-                },
-            ],
-        };
-    }
-    return { theme: parsed.data, diagnostics: [] };
-}
-function pickDefined(target, source) {
-    for (const key of ["accent", "background", "logo", "name", "fontFamily"]) {
-        const value = source[key];
-        if (value !== undefined) {
-            target[key] = value;
-        }
-    }
-}
-/**
- * Compiles the full tier-3 cascade into the flat token shape the runtime
- * already reads. `base` is the existing free-tier `spacefast.jsonc
- * "pages.theme"` (already validated by `spaceConfigSchema` upstream — passed
- * through as-is). `sf.theme.jsonc` only applies when `advancedThemingEntitled`
- * is true; when it is present but NOT entitled, the tier is skipped with an
- * info diagnostic (fail-safe by omission — the compiled artifact simply
- * reflects the lower, entitled tiers, per access-plan §9).
- */
-export function mergeGateTheme(input) {
-    const diagnostics = [];
-    const merged = {};
-    if (input.base) {
-        pickDefined(merged, input.base);
-    }
-    let themeVars = null;
-    if (input.themeJsonRaw !== null) {
-        const parsed = parseThemeJsonFile(input.themeJsonRaw);
-        diagnostics.push(...parsed.diagnostics);
-        pickDefined(merged, parsed.theme);
-        themeVars = parsed.themeVars;
-    }
-    if (input.sfThemeJsoncRaw !== null) {
-        if (!input.advancedThemingEntitled) {
-            diagnostics.push({
-                severity: "info",
-                code: "sf_theme_jsonc_not_entitled",
-                message: "sf.theme.jsonc is a paid (advanced theming) tier; this plan is not entitled, so it was ignored.",
-                path: "sf.theme.jsonc",
-            });
-        }
-        else {
-            const parsed = parseSfThemeJsonc(input.sfThemeJsoncRaw);
-            diagnostics.push(...parsed.diagnostics);
-            pickDefined(merged, parsed.theme);
-        }
-    }
-    return { theme: merged, themeVars, diagnostics };
-}

package/dist/utils/space-theme.d.ts

@@ -1,18 +0,0 @@
-import type { SpaceTheme } from "../contracts/space-theme.js";
-export type SpaceThemeWarning = {
-    severity: "warning";
-    code: "theme_value_invalid";
-    message: string;
-    /** JSON-path-lite pointer into the theme shape. */
-    path: string;
-};
-export type CompiledSpaceTheme = {
-    /** CSS custom-property declarations (no selector), or null when empty. */
-    css: string | null;
-    warnings: SpaceThemeWarning[];
-};
-/** Engine-enforced ceiling for the compiled declaration block. */
-export declare const SPACE_THEME_CSS_MAX_BYTES: number;
-export declare function isSafeThemeColor(value: string): boolean;
-export declare function isSafeThemeFontFamily(value: string): boolean;
-export declare function compileSpaceTheme(theme: SpaceTheme | null | undefined): CompiledSpaceTheme;

package/dist/utils/space-theme.js

@@ -1,98 +0,0 @@
-/** Engine-enforced ceiling for the compiled declaration block. */
-export const SPACE_THEME_CSS_MAX_BYTES = 16 * 1024;
-// Categorically forbidden anywhere in a value: network reach, style escape,
-// markup injection. Mirrors the runtime's defense-in-depth re-check.
-const FORBIDDEN_VALUE_PATTERN = /url\s*\(|@import|expression\s*\(|data:|[<>{};\\]|\/\*|\*\//i;
-const COLOR_PATTERN = new RegExp([
-    "^(?:",
-    "#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})",
-    "|rgba?\\([0-9.,\\s%/]{1,64}\\)",
-    "|hsla?\\([0-9.,\\s%deg/]{1,64}\\)",
-    "|[a-zA-Z]{3,30}", // CSS named colors (transparent, currentColor, rebeccapurple, ...)
-    "|var\\(--wp--preset--color--[a-z0-9-]{1,64}\\)",
-    ")$",
-].join(""));
-const SIZE_PATTERN = new RegExp([
-    "^(?:",
-    "-?\\d{1,5}(?:\\.\\d{1,4})?(?:px|rem|em|%|vw|vh|vmin|vmax|pt|ch|ex)?",
-    "|var\\(--wp--preset--(?:font-size|spacing)--[a-z0-9-]{1,64}\\)",
-    ")$",
-].join(""));
-// Font family stacks: platform-provided or validated-generic family names
-// only — letters, digits, spaces, commas, hyphens, straight quotes. No src.
-const FONT_FAMILY_PATTERN = /^[A-Za-z0-9 ,'"-]{1,256}$/;
-function safeValue(value, pattern) {
-    const trimmed = value.trim();
-    return trimmed.length > 0 && !FORBIDDEN_VALUE_PATTERN.test(trimmed) && pattern.test(trimmed);
-}
-// Exported so other compilers that consume the same preset grammar (the gate-page
-// theme cascade's `theme.json`/`sf.theme.jsonc` tiers, access-plan §8) reuse this
-// ONE allowlist instead of re-deriving it — same posture, same forbidden set.
-export function isSafeThemeColor(value) {
-    return safeValue(value, COLOR_PATTERN);
-}
-export function isSafeThemeFontFamily(value) {
-    return safeValue(value, FONT_FAMILY_PATTERN);
-}
-export function compileSpaceTheme(theme) {
-    if (!theme) {
-        return { css: null, warnings: [] };
-    }
-    const declarations = [];
-    const warnings = [];
-    const drop = (path) => {
-        warnings.push({
-            severity: "warning",
-            code: "theme_value_invalid",
-            message: `Theme value at ${path} is not a safe preset token and was dropped.`,
-            path,
-        });
-    };
-    theme.color?.palette?.forEach((entry, index) => {
-        if (safeValue(entry.color, COLOR_PATTERN)) {
-            declarations.push(`--wp--preset--color--${entry.slug}:${entry.color.trim()}`);
-        }
-        else {
-            drop(`theme.color.palette[${index}].color`);
-        }
-    });
-    theme.typography?.fontSizes?.forEach((entry, index) => {
-        if (safeValue(entry.size, SIZE_PATTERN)) {
-            declarations.push(`--wp--preset--font-size--${entry.slug}:${entry.size.trim()}`);
-        }
-        else {
-            drop(`theme.typography.fontSizes[${index}].size`);
-        }
-    });
-    const fontFamily = theme.typography?.fontFamily;
-    if (fontFamily !== undefined) {
-        if (safeValue(fontFamily, FONT_FAMILY_PATTERN)) {
-            declarations.push(`--sf--font-family:${fontFamily.trim()}`);
-        }
-        else {
-            drop("theme.typography.fontFamily");
-        }
-    }
-    theme.spacing?.spacingScale?.forEach((entry, index) => {
-        if (safeValue(entry.size, SIZE_PATTERN)) {
-            declarations.push(`--wp--preset--spacing--${entry.slug}:${entry.size.trim()}`);
-        }
-        else {
-            drop(`theme.spacing.spacingScale[${index}].size`);
-        }
-    });
-    // Bounded output: drop trailing declarations past the engine ceiling with a
-    // warning instead of failing the version.
-    let css = declarations.join(";");
-    while (css.length > SPACE_THEME_CSS_MAX_BYTES && declarations.length > 0) {
-        declarations.pop();
-        warnings.push({
-            severity: "warning",
-            code: "theme_value_invalid",
-            message: `Compiled theme exceeds ${SPACE_THEME_CSS_MAX_BYTES} bytes; trailing tokens were dropped.`,
-            path: "theme",
-        });
-        css = declarations.join(";");
-    }
-    return { css: css.length > 0 ? css : null, warnings };
-}