@opencode-ai/theme 0.0.0-next-16413

package/dist/tui/resolve.js

@@ -0,0 +1,214 @@
+import { RGBA } from "@opentui/core";
+import { Schema } from "effect";
+import { DEFAULT_CATEGORICAL, DEFAULT_THEME } from "./defaults.js";
+import { expandTheme, expandTokens, mergeTheme } from "./expand.js";
+import { fallback } from "./fallback.js";
+import { ActionState, ActionVariant, BaseHue, FeedbackKind, HueAlias, HueStep, ThemeDefinition, ThemeDocument, } from "./schema.js";
+import { selectTheme, selectThemeMode } from "./select.js";
+const decodeThemeDefinitionSchema = Schema.decodeUnknownSync(ThemeDefinition);
+function decodeThemeDefinition(input) {
+    try {
+        return decodeThemeDefinitionSchema(input);
+    }
+    catch (error) {
+        throw themeDecodeError(error, "theme");
+    }
+}
+export function themeDecodeError(error, name) {
+    const message = Schema.isSchemaError(error) ? error.message : String(error);
+    const value = /got ("[^"]*"|\S+)/.exec(message)?.[1] ?? "value";
+    return new Error(`Invalid theme: ${name} ${value} is an invalid value`, { cause: error });
+}
+export function resolveThemeDocument(document, mode) {
+    const selected = selectThemeMode(document, mode);
+    const definition = selected.expanded ? selected.theme : expandTheme(selected.theme);
+    const defaults = expandTheme(selectTheme(DEFAULT_THEME, selected.mode));
+    const core = expandTokens(fallback());
+    const merged = document.standalone ? mergeTheme(core, definition) : mergeTheme(core, defaults, definition);
+    if (!merged["hue"])
+        throw new Error("Standalone themes must provide hues");
+    return resolveExpandedTheme({
+        ...merged,
+        categorical: merged["categorical"] ?? DEFAULT_CATEGORICAL,
+    });
+}
+export function resolveTheme(definition) {
+    return resolveExpandedTheme(expandTheme(decodeThemeDefinition(definition)));
+}
+function resolveExpandedTheme(definition) {
+    const hue = resolveHue(definition.hue);
+    const categorical = (definition.categorical ?? DEFAULT_CATEGORICAL).map((name) => hue[name]);
+    const hueSteps = compileHueSteps(hue);
+    const base = tokens(definition);
+    const resolved = resolveView(base, hue, categorical, hueSteps);
+    const contexts = Object.fromEntries(Object.entries(definition)
+        .filter(([key]) => key.startsWith("@context:"))
+        .map(([key, override]) => {
+        const contextual = contextualize(base, override);
+        return [key, resolveView(contextual, hue, categorical, hueSteps)];
+    }));
+    return { ...resolved, contexts };
+}
+function tokens(definition) {
+    return {
+        text: definition.text,
+        background: definition.background,
+        border: definition.border,
+        scrollbar: definition.scrollbar,
+        diff: definition.diff,
+        syntax: definition.syntax,
+        markdown: definition.markdown,
+    };
+}
+function contextualize(base, override) {
+    const result = mergeTheme(base, override);
+    const baseText = base.text?.action;
+    const contextText = override.text?.action;
+    const baseBackground = base.background?.action;
+    const contextBackground = override.background?.action;
+    const text = result["text"];
+    const background = result["background"];
+    return {
+        ...result,
+        text: { ...text, action: contextualActions(baseText, contextText) },
+        background: { ...background, action: contextualActions(baseBackground, contextBackground) },
+    };
+}
+function contextualActions(base, context) {
+    return Object.fromEntries(ActionVariant.literals.map((variant) => {
+        const baseVariant = base?.[variant];
+        const contextVariant = context?.[variant];
+        return [
+            variant,
+            Object.fromEntries(["default", ...ActionState.literals].map((state) => {
+                const key = state === "default" ? undefined : `$${state}`;
+                return [
+                    key ?? "default",
+                    (key ? contextVariant?.[key] : undefined) ??
+                        contextVariant?.default ??
+                        (key ? baseVariant?.[key] : undefined) ??
+                        baseVariant?.default,
+                ];
+            })),
+        ];
+    }));
+}
+function resolveView(definition, hue, categorical, hueSteps) {
+    const source = { hue, ...definition };
+    return { ...createResolver(source)(source, "theme"), hue, categorical, ...hueSteps };
+}
+function compileHueSteps(hue) {
+    const index = new WeakMap();
+    for (const [name, scale] of Object.entries(hue)) {
+        HueStep.literals.forEach((step, position) => index.set(scale[step], { hue: name, step, position }));
+    }
+    const shift = (color, amount) => {
+        const match = index.get(color);
+        if (!match)
+            return color;
+        const offset = Number.isFinite(amount) ? Math.trunc(amount) : 0;
+        const position = Math.max(0, Math.min(HueStep.literals.length - 1, match.position + offset));
+        return hue[match.hue][HueStep.literals[position]];
+    };
+    return {
+        source: (color) => {
+            const match = index.get(color);
+            return match ? { hue: match.hue, step: match.step } : undefined;
+        },
+        increase: (color, amount = 1) => shift(color, amount),
+        decrease: (color, amount = 1) => shift(color, -amount),
+    };
+}
+function resolveHue(definition) {
+    const source = definition;
+    const cache = new Map();
+    const expected = new Set([...BaseHue.literals, ...HueAlias.literals]);
+    for (const name of Object.keys(source)) {
+        if (!expected.has(name))
+            throw new Error(`Unknown hue "${name}"`);
+    }
+    function resolve(name, stack) {
+        const hit = cache.get(name);
+        if (hit)
+            return hit;
+        if (stack.includes(name))
+            throw new Error(`Circular hue reference: ${[...stack, name].join(" -> ")}`);
+        const value = source[name];
+        if (typeof value === "string") {
+            const match = /^\$hue\.([^.]+)$/.exec(value);
+            if (!match?.[1])
+                throw new Error(`Hue alias "${value}" must reference a hue scale`);
+            const target = resolve(match[1], [...stack, name]);
+            const result = Object.fromEntries(HueStep.literals.map((step) => [step, RGBA.clone(target[step])]));
+            cache.set(name, result);
+            return result;
+        }
+        if (!isRecord(value))
+            throw new Error(`Hue "${name}" was not found`);
+        const result = Object.fromEntries(HueStep.literals.map((step) => {
+            const color = value[step];
+            if (typeof color !== "string" || !isHex(color))
+                throw new Error(`Invalid hue color at "hue.${name}.${step}"`);
+            return [step, RGBA.fromHex(color)];
+        }));
+        for (const step of Object.keys(value)) {
+            if (!HueStep.literals.includes(Number(step)))
+                throw new Error(`Unknown hue step at "hue.${name}.${step}"`);
+        }
+        cache.set(name, result);
+        return result;
+    }
+    return Object.fromEntries([...BaseHue.literals, ...HueAlias.literals].map((name) => [name, resolve(name, [])]));
+}
+function createResolver(source) {
+    const cache = new Map();
+    function resolve(value, path, stack = []) {
+        if (value instanceof RGBA)
+            return value;
+        if (typeof value === "string")
+            return resolveColor(value, path, stack);
+        if (typeof value === "number")
+            return value;
+        if (!isRecord(value))
+            throw new Error(`Invalid theme value at "${path}"`);
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [resolvedKey(key), resolve(item, `${path}.${key}`, stack)]));
+    }
+    function resolveColor(value, path, stack) {
+        if (value === "transparent")
+            return RGBA.fromInts(0, 0, 0, 0);
+        if (isHex(value))
+            return RGBA.fromHex(value);
+        if (!value.startsWith("$"))
+            throw new Error(`Invalid color "${value}" at "${path}"`);
+        const target = value.slice(1);
+        const hit = cache.get(target);
+        if (hit)
+            return hit;
+        if (stack.includes(target))
+            throw new Error(`Circular theme reference: ${[...stack, target].join(" -> ")}`);
+        const result = resolve(read(source, target), target, [...stack, target]);
+        if (!(result instanceof RGBA))
+            throw new Error(`Theme reference "${value}" at "${path}" is not a color`);
+        cache.set(target, result);
+        return result;
+    }
+    return (value, path) => resolve(value, path);
+}
+function resolvedKey(key) {
+    if (!key.startsWith("$"))
+        return key;
+    const state = key.slice(1);
+    return ActionState.literals.includes(state) ? state : key;
+}
+function read(source, path) {
+    const result = path.split(".").reduce((value, key) => (isRecord(value) ? value[key] : undefined), source);
+    if (result === undefined)
+        throw new Error(`Theme reference "$${path}" was not found`);
+    return result;
+}
+function isHex(value) {
+    return /^#(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})$/i.test(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof RGBA);
+}