Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { parseThemeVarsText, validateVarEntry } from "./custom-theme";
import type {
Theme,
ThemeDefinition,
ThemeInfo,
ThemeMode,
ThemeVarName,
ThemeVars,
} from "./types";
export type ThemeExportFormat = "ts" | "json" | "css";
export type ParsedThemeInput = {
info: Partial<ThemeInfo>;
definition: ThemeDefinition;
/** Merge into the current theme instead of replacing it (bare declarations, a lone CSS block). */
partial: boolean;
/** Dropped vars / values — the rest of the input still applied. */
warnings: string[];
};
export type ParseThemeInputResult =
| ({ ok: true } & ParsedThemeInput)
| { ok: false; error: string };
/**
* Parses anything a builder, an agent or a theme file hands over: a `Theme`
* (or `{ light, dark }`) as JSON or as a TS/JS object literal, CSS with
* `:root { }` / `.dark { }` blocks, or bare `--name: value;` declarations
* (applied to `fallbackMode`).
*/
export function parseThemeInput(
text: string,
fallbackMode: ThemeMode = "light",
): ParseThemeInputResult {
const source = text.trim();
if (source.length === 0) return { ok: false, error: "Nothing to paste." };
const light = cssBlock(source, [":root", ".light"]);
const dark = cssBlock(source, [".dark"]);
const parsed =
light !== undefined || dark !== undefined
? parseCssBlocks(light, dark)
: source.includes("{")
? parseObjectLiteral(source, fallbackMode)
: parseDeclarations(source, fallbackMode);
if (!parsed.ok) return parsed;
const hasVars =
Object.keys(parsed.definition.light).length > 0 ||
Object.keys(parsed.definition.dark).length > 0;
if (!hasVars) {
const detail = parsed.warnings[0] ? ` ${parsed.warnings[0]}` : "";
return { ok: false, error: `No supported CSS variables found.${detail}` };
}
return parsed;
}
function parseDeclarations(
source: string,
mode: ThemeMode,
): ParseThemeInputResult {
const { vars, errors } = parseThemeVarsText(source);
const definition: ThemeDefinition = { light: {}, dark: {} };
definition[mode] = vars;
return { ok: true, info: {}, definition, partial: true, warnings: errors };
}
/** Body of the first `selector { … }`; indexOf instead of a regex (CodeQL js/polynomial-redos). */
function cssBlock(source: string, selectors: string[]) {
for (const selector of selectors) {
let from = 0;
let start = source.indexOf(selector, from);
while (start !== -1) {
from = start + selector.length;
const open = source.indexOf("{", from);
if (open === -1) break;
// `.light-theme {` is not `.light {`
if (source.slice(from, open).trim().length === 0) {
const close = source.indexOf("}", open);
return close === -1 ? undefined : source.slice(open + 1, close);
}
start = source.indexOf(selector, from);
}
}
return undefined;
}
function parseCssBlocks(
light: string | undefined,
dark: string | undefined,
): ParseThemeInputResult {
const lightResult = parseThemeVarsText(light ?? "");
const darkResult = parseThemeVarsText(dark ?? "");
return {
ok: true,
info: {},
definition: { light: lightResult.vars, dark: darkResult.vars },
// a lone block must not wipe the other mode
partial: light === undefined || dark === undefined,
warnings: [...lightResult.errors, ...darkResult.errors],
};
}
function parseObjectLiteral(
source: string,
fallbackMode: ThemeMode,
): ParseThemeInputResult {
// `import type { Theme }` carries a brace before the literal; everything
// else ahead of it (comments, fences, prose) is skipped by objectStart
const stripped = source.replace(/^\s*import\b[^\n]*$/gm, "");
const from = objectStart(stripped);
if (from === -1) {
return { ok: false, error: "Expected an object with light / dark vars." };
}
const json = toJson(stripped.slice(from).replace(/\bas const\b/g, ""));
const start = json.indexOf("{");
const end = json.lastIndexOf("}");
if (start === -1 || end <= start) {
return { ok: false, error: "Expected an object with light / dark vars." };
}
let value: unknown;
try {
value = JSON.parse(json.slice(start, end + 1));
} catch {
return {
ok: false,
error:
"Could not parse the configuration. Paste the JSON or the theme file as is.",
};
}
if (!isRecord(value)) {
return { ok: false, error: "Expected an object with light / dark vars." };
}
const warnings: string[] = [];
const definition: ThemeDefinition = { light: {}, dark: {} };
let partial = false;
if (isRecord(value.light) || isRecord(value.dark)) {
// `{ light }` alone must not wipe dark (and vice versa)
partial = value.light === undefined || value.dark === undefined;
for (const mode of ["light", "dark"] as const) {
const vars = value[mode];
if (vars === undefined) continue;
if (!isRecord(vars)) {
warnings.push(`"${mode}" must be an object of CSS variables.`);
continue;
}
definition[mode] = pickVars(vars, warnings);
}
} else if (Object.keys(value).some((key) => key.startsWith("--"))) {
definition[fallbackMode] = pickVars(value, warnings);
partial = true;
} else {
return { ok: false, error: "Expected an object with light / dark vars." };
}
const info: Partial<ThemeInfo> = {};
if (typeof value.id === "string" && value.id.trim())
info.id = value.id.trim();
if (typeof value.name === "string" && value.name.trim()) {
info.name = value.name.trim();
}
if (
isRecord(value.author) &&
typeof value.author.name === "string" &&
typeof value.author.url === "string"
) {
info.author = { name: value.author.name, url: value.author.url };
}
return { ok: true, info, definition, partial, warnings };
}
function pickVars(
input: Record<string, unknown>,
warnings: string[],
): ThemeVars {
const vars: ThemeVars = {};
for (const [name, raw] of Object.entries(input)) {
if (typeof raw !== "string") {
warnings.push(`Value of "${name}" must be a string.`);
continue;
}
const errors = validateVarEntry(name, raw);
if (errors.length > 0) {
warnings.push(...errors);
continue;
}
// safe: validateVarEntry checked membership in THEME_VAR_NAMES
vars[name as ThemeVarName] = raw.trim();
}
return vars;
}
/** Index of the first `{` outside a comment; the body itself is left to the string-aware toJson. */
function objectStart(source: string) {
let i = 0;
while (i < source.length) {
if (source.startsWith("//", i)) {
const end = source.indexOf("\n", i);
if (end === -1) return -1;
i = end + 1;
} else if (source.startsWith("/*", i)) {
const end = source.indexOf("*/", i + 2);
if (end === -1) return -1;
i = end + 2;
} else if (source.charAt(i) === "{") {
return i;
} else {
i++;
}
}
return -1;
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
/**
* Rewrites a TS/JS object literal into strict JSON: strips comments, quotes
* bare keys, normalizes quotes and drops trailing commas. String-aware, so
* `//` inside an author url survives.
*/
function toJson(source: string): string {
let out = "";
let i = 0;
while (i < source.length) {
const ch = source.charAt(i);
if (ch === '"' || ch === "'" || ch === "`") {
let j = i + 1;
let str = "";
while (j < source.length && source[j] !== ch) {
if (source[j] === "\\") {
str += source[j + 1] ?? "";
j += 2;
continue;
}
str += source.charAt(j);
j++;
}
out += JSON.stringify(str);
i = j + 1;
continue;
}
if (ch === "/" && source[i + 1] === "/") {
while (i < source.length && source[i] !== "\n") i++;
continue;
}
if (ch === "/" && source[i + 1] === "*") {
const end = source.indexOf("*/", i + 2);
i = end === -1 ? source.length : end + 2;
continue;
}
if (/[A-Za-z_$]/.test(ch)) {
let j = i;
while (j < source.length && /[\w$]/.test(source.charAt(j))) j++;
const word = source.slice(i, j);
let k = j;
while (k < source.length && /\s/.test(source.charAt(k))) k++;
if (source[k] === ":") {
out += `${JSON.stringify(word)}:`;
i = k + 1;
} else {
out += word;
i = j;
}
continue;
}
// comments are already gone from `out`, so a trailing comma is whatever
// precedes the closing bracket
if (ch === "}" || ch === "]") out = out.replace(/,\s*$/, "");
out += ch;
i++;
}
return out;
}
/** Serializes a theme for the clipboard: theme file, JSON or CSS blocks. */
export function serializeTheme(theme: Theme, format: ThemeExportFormat) {
switch (format) {
case "json":
return JSON.stringify(theme, null, 2);
case "css":
return `:root {\n${formatBlock(theme.light)}\n}\n.dark {\n${formatBlock(theme.dark)}\n}`;
case "ts":
return [
`// packages/theme-store/src/${theme.id}.ts`,
`import type { Theme } from "./types";`,
"",
`export const ${constName(theme.id)} = {`,
` id: ${JSON.stringify(theme.id)},`,
` name: ${JSON.stringify(theme.name)},`,
` author: { name: ${JSON.stringify(theme.author.name)}, url: ${JSON.stringify(theme.author.url)} },`,
` light: {\n${formatObject(theme.light)}\n },`,
` dark: {\n${formatObject(theme.dark)}\n },`,
"} as const satisfies Theme;",
].join("\n");
}
}
function constName(id: string) {
const base = id
.toUpperCase()
.replace(/[^A-Z0-9]+/g, "_")
.replace(/^_|_$/g, "")
.replace(/_?THEME$/, "");
return `${base || "MY"}_THEME`;
}
function formatBlock(vars: ThemeVars) {
return Object.entries(vars)
.map(([name, value]) => ` ${name}: ${value};`)
.join("\n");
}
function formatObject(vars: ThemeVars) {
return Object.entries(vars)
.map(
([name, value]) =>
` ${JSON.stringify(name)}: ${JSON.stringify(value)},`,
)
.join("\n");
}