@opencode-ai/theme 0.0.0-next-16415 → 0.0.0

package/dist/tui/schema.js

@@ -1,182 +0,0 @@
-import { Schema } from "effect";
-export const HueStep = Schema.Literals([100, 200, 300, 400, 500, 600, 700, 800, 900]);
-export const BaseHue = Schema.Literals(["gray", "red", "orange", "yellow", "green", "cyan", "blue", "purple"]);
-export const HueAlias = Schema.Literals(["accent", "interactive", "neutral"]);
-export const ActionVariant = Schema.Literals(["primary", "destructive"]);
-export const ActionState = Schema.Literals(["disabled", "pressed", "focused", "selected", "hovered"]);
-export const FormfieldState = ActionState;
-export const FeedbackKind = Schema.Literals(["error", "warning", "success", "info"]);
-const Mode = Schema.Literals(["light", "dark"]);
-const HexColor = Schema.String.check(Schema.isPattern(/^#(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})$/i));
-const ColorValue = Schema.Union([
-    HexColor,
-    Schema.Literal("transparent"),
-    Schema.TemplateLiteral(["$", Schema.NonEmptyString]),
-]);
-export const HueName = Schema.Union([BaseHue, HueAlias]);
-export const CategoricalDefinition = Schema.Array(HueName).check(Schema.isMinLength(1));
-const HueColorValue = Schema.Union([HexColor, Schema.TemplateLiteral(["$hue.", HueName, ".", HueStep])]);
-const ContextKey = Schema.Literals(["@context:elevated", "@context:overlay"]);
-const HueScaleDefinition = Schema.Record(HueStep, HexColor);
-const HueValueDefinition = Schema.Union([Schema.TemplateLiteral(["$hue.", HueName]), HueScaleDefinition]);
-const HueDefinition = Schema.Struct({
-    gray: HueValueDefinition,
-    red: HueValueDefinition,
-    orange: HueValueDefinition,
-    yellow: HueValueDefinition,
-    green: HueValueDefinition,
-    cyan: HueValueDefinition,
-    blue: HueValueDefinition,
-    purple: HueValueDefinition,
-    accent: HueValueDefinition,
-    interactive: HueValueDefinition,
-    neutral: HueValueDefinition,
-});
-const HueOverrideDefinition = Schema.Struct({
-    gray: Schema.optional(HueValueDefinition),
-    red: Schema.optional(HueValueDefinition),
-    orange: Schema.optional(HueValueDefinition),
-    yellow: Schema.optional(HueValueDefinition),
-    green: Schema.optional(HueValueDefinition),
-    cyan: Schema.optional(HueValueDefinition),
-    blue: Schema.optional(HueValueDefinition),
-    purple: Schema.optional(HueValueDefinition),
-    accent: Schema.optional(HueValueDefinition),
-    interactive: Schema.optional(HueValueDefinition),
-    neutral: Schema.optional(HueValueDefinition),
-});
-const StatefulColorDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-    $hovered: Schema.optional(ColorValue),
-    $focused: Schema.optional(ColorValue),
-    $pressed: Schema.optional(ColorValue),
-    $selected: Schema.optional(ColorValue),
-    $disabled: Schema.optional(ColorValue),
-});
-const ActionColorDefinition = Schema.Struct({
-    primary: Schema.optional(StatefulColorDefinition),
-    destructive: Schema.optional(StatefulColorDefinition),
-});
-const TextFeedbackDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-    subdued: Schema.optional(ColorValue),
-});
-const BackgroundFeedbackDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-});
-const TextDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-    subdued: Schema.optional(ColorValue),
-    action: Schema.optional(ActionColorDefinition),
-    formfield: Schema.optional(StatefulColorDefinition),
-    feedback: Schema.optional(Schema.Struct({
-        error: Schema.optional(TextFeedbackDefinition),
-        warning: Schema.optional(TextFeedbackDefinition),
-        success: Schema.optional(TextFeedbackDefinition),
-        info: Schema.optional(TextFeedbackDefinition),
-    })),
-});
-const BackgroundDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-    surface: Schema.optional(Schema.Struct({
-        offset: Schema.optional(ColorValue),
-        overlay: Schema.optional(ColorValue),
-    })),
-    action: Schema.optional(ActionColorDefinition),
-    formfield: Schema.optional(StatefulColorDefinition),
-    feedback: Schema.optional(Schema.Struct({
-        error: Schema.optional(BackgroundFeedbackDefinition),
-        warning: Schema.optional(BackgroundFeedbackDefinition),
-        success: Schema.optional(BackgroundFeedbackDefinition),
-        info: Schema.optional(BackgroundFeedbackDefinition),
-    })),
-});
-export const SyntaxToken = Schema.Literals([
-    "comment",
-    "keyword",
-    "function",
-    "variable",
-    "string",
-    "number",
-    "type",
-    "operator",
-    "punctuation",
-]);
-export const SyntaxDefinition = Schema.Record(SyntaxToken, Schema.optionalKey(HueColorValue));
-export const MarkdownToken = Schema.Literals([
-    "text",
-    "heading",
-    "link",
-    "linkText",
-    "code",
-    "blockQuote",
-    "emphasis",
-    "strong",
-    "horizontalRule",
-    "listItem",
-    "listEnumeration",
-    "image",
-    "imageText",
-    "codeBlock",
-]);
-export const MarkdownDefinition = Schema.Record(MarkdownToken, Schema.optionalKey(HueColorValue));
-const DiffDefinition = Schema.Struct({
-    text: Schema.optional(Schema.Struct({
-        added: Schema.optional(ColorValue),
-        removed: Schema.optional(ColorValue),
-        context: Schema.optional(ColorValue),
-        hunkHeader: Schema.optional(ColorValue),
-    })),
-    background: Schema.optional(Schema.Struct({
-        added: Schema.optional(ColorValue),
-        removed: Schema.optional(ColorValue),
-        context: Schema.optional(ColorValue),
-    })),
-    highlight: Schema.optional(Schema.Struct({ added: Schema.optional(ColorValue), removed: Schema.optional(ColorValue) })),
-    lineNumber: Schema.optional(Schema.Struct({
-        text: Schema.optional(ColorValue),
-        background: Schema.optional(Schema.Struct({ added: Schema.optional(ColorValue), removed: Schema.optional(ColorValue) })),
-    })),
-});
-const ThemeTokensDefinition = Schema.Struct({
-    text: Schema.optional(TextDefinition),
-    background: Schema.optional(BackgroundDefinition),
-    border: Schema.optional(Schema.Struct({ default: Schema.optional(ColorValue) })),
-    scrollbar: Schema.optional(Schema.Struct({ default: Schema.optional(ColorValue) })),
-    diff: Schema.optional(DiffDefinition),
-    syntax: Schema.optional(SyntaxDefinition),
-    markdown: Schema.optional(MarkdownDefinition),
-});
-const ThemeDefinitionFields = Schema.Struct({
-    hue: HueDefinition,
-    categorical: Schema.optional(CategoricalDefinition),
-    ...ThemeTokensDefinition.fields,
-    "@context:elevated": Schema.optional(ThemeTokensDefinition),
-    "@context:overlay": Schema.optional(ThemeTokensDefinition),
-});
-export const ThemeDefinition = ThemeDefinitionFields;
-const FileThemeDefinition = Schema.Struct({
-    hue: Schema.optional(HueOverrideDefinition),
-    categorical: Schema.optional(CategoricalDefinition),
-    ...ThemeTokensDefinition.fields,
-    "@context:elevated": Schema.optional(ThemeTokensDefinition),
-    "@context:overlay": Schema.optional(ThemeTokensDefinition),
-});
-const MergeModeDefinition = Schema.Struct({
-    mergeMode: Schema.Literal(true),
-    hue: Schema.optional(HueOverrideDefinition),
-    categorical: Schema.optional(CategoricalDefinition),
-    ...ThemeTokensDefinition.fields,
-    "@context:elevated": Schema.optional(ThemeTokensDefinition),
-    "@context:overlay": Schema.optional(ThemeTokensDefinition),
-});
-export const ModeDefinition = Schema.Union([MergeModeDefinition, FileThemeDefinition]);
-const FileMetadata = {
-    $schema: Schema.optional(Schema.String),
-    version: Schema.Literal(2),
-    standalone: Schema.optional(Schema.Boolean),
-};
-export const ThemeDocument = Schema.Union([
-    Schema.Struct({ ...FileMetadata, light: ModeDefinition, dark: Schema.optional(ModeDefinition) }),
-    Schema.Struct({ ...FileMetadata, light: Schema.optional(ModeDefinition), dark: ModeDefinition }),
-]);

package/dist/tui/select.d.ts

@@ -1,13 +0,0 @@
-import type { FileThemeDefinition, Mode, ThemeDefinition, ThemeDocument } from "./index.js";
-export declare function selectTheme(document: ThemeDocument & {
-    light: ThemeDefinition;
-    dark: ThemeDefinition;
-}, mode?: Mode): ThemeDefinition;
-export declare function selectTheme(document: ThemeDocument, mode?: Mode): FileThemeDefinition;
-export declare function selectThemeMode(document: ThemeDocument, mode?: Mode): {
-    theme: FileThemeDefinition;
-    mode: Mode;
-    expanded: boolean;
-};
-export declare function themeModes(document: ThemeDocument): readonly Mode[];
-export declare function supportsThemeMode(document: ThemeDocument, mode: Mode): boolean;

package/dist/tui/select.js

@@ -1,36 +0,0 @@
-import { expandTheme, mergeTheme } from "./expand.js";
-export function selectTheme(document, mode) {
-    return selectThemeMode(document, mode).theme;
-}
-export function selectThemeMode(document, mode = "light") {
-    const modes = themeModes(document);
-    const selectedMode = modes.includes(mode) ? mode : modes[0];
-    const selected = document[selectedMode];
-    if (!selected)
-        throw new Error("Theme must provide at least one mode");
-    if (merges(document.light) && merges(document.dark))
-        throw new Error("Light and dark themes cannot both merge modes");
-    if (!merges(selected))
-        return { theme: selected, mode: selectedMode, expanded: false };
-    const otherMode = selectedMode === "light" ? "dark" : "light";
-    const other = document[otherMode];
-    if (!other)
-        throw new Error(`The ${selectedMode} theme cannot merge without a ${otherMode} theme`);
-    const merged = mergeTheme(expandTheme(other), expandTheme(selected));
-    if (!merged["hue"])
-        throw new Error(`The ${otherMode} theme must provide hues when ${selectedMode} merges modes`);
-    return { theme: merged, mode: selectedMode, expanded: true };
-}
-export function themeModes(document) {
-    if (merges(document.light) && !document.dark)
-        throw new Error("The light theme cannot merge without a dark theme");
-    if (merges(document.dark) && !document.light)
-        throw new Error("The dark theme cannot merge without a light theme");
-    return ["light", "dark"].filter((mode) => document[mode] !== undefined);
-}
-export function supportsThemeMode(document, mode) {
-    return themeModes(document).includes(mode);
-}
-function merges(definition) {
-    return definition !== undefined && "mergeMode" in definition && definition.mergeMode === true;
-}

package/dist/tui/syntax.d.ts

@@ -1,3 +0,0 @@
-import { SyntaxStyle } from "@opentui/core";
-import type { Mode, ResolvedThemeView } from "./index.js";
-export declare function generateSyntax(theme: ResolvedThemeView, mode: Mode): SyntaxStyle;

package/dist/tui/syntax.js

@@ -1,75 +0,0 @@
-import { SyntaxStyle } from "@opentui/core";
-export function generateSyntax(theme, mode) {
-    const step = mode === "light" ? 800 : 200;
-    const syntax = theme.syntax;
-    const markdown = theme.markdown;
-    const feedback = theme.text.feedback;
-    return SyntaxStyle.fromTheme([
-        rule(["default"], theme.text.default),
-        rule(["prompt"], theme.hue.accent[step]),
-        rule(["extmark.file"], feedback.warning.default, { bold: true }),
-        rule(["extmark.agent"], theme.categorical[0][step], { bold: true }),
-        // V1 migration preserves its selected/inverse foreground in this action state.
-        rule(["extmark.paste"], theme.text.action.primary.focused, {
-            background: feedback.warning.default,
-            bold: true,
-        }),
-        rule(["comment", "comment.documentation"], syntax.comment, { italic: true }),
-        rule(["string", "symbol", "character.special", "character"], syntax.string),
-        rule(["number", "boolean", "constant", "float"], syntax.number),
-        rule(["keyword.return", "keyword.conditional", "keyword.repeat", "keyword.coroutine"], syntax.keyword, {
-            italic: true,
-        }),
-        rule(["keyword.type"], syntax.type, { bold: true, italic: true }),
-        rule(["keyword.function", "function.method"], syntax.function),
-        rule(["keyword"], syntax.keyword, { italic: true }),
-        rule(["keyword.import", "string.escape", "string.regexp", "tag.attribute", "keyword.export"], syntax.keyword),
-        rule(["operator", "keyword.operator", "punctuation.delimiter", "keyword.conditional.ternary"], syntax.operator),
-        rule(["variable", "variable.parameter", "function.method.call", "function.call", "property", "parameter", "field"], syntax.variable),
-        rule(["variable.member", "function", "constructor"], syntax.function),
-        rule(["type", "module", "class", "namespace"], syntax.type),
-        rule(["type.definition"], syntax.type, { bold: true }),
-        rule(["punctuation", "punctuation.bracket"], syntax.punctuation),
-        rule(["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super"], feedback.error.default),
-        rule(["keyword.directive", "keyword.modifier", "keyword.exception"], syntax.keyword, { italic: true }),
-        rule(["punctuation.special", "tag.delimiter"], syntax.operator),
-        rule([
-            "markup.heading",
-            "markup.heading.2",
-            "markup.heading.3",
-            "markup.heading.4",
-            "markup.heading.5",
-            "markup.heading.6",
-        ], markdown.heading, { bold: true }),
-        rule(["markup.heading.1"], markdown.heading, { bold: true, underline: true }),
-        rule(["markup.bold", "markup.strong"], markdown.strong, { bold: true }),
-        rule(["markup.italic"], markdown.emphasis, { italic: true }),
-        rule(["markup.list"], markdown.listItem),
-        rule(["markup.quote"], markdown.blockQuote, { italic: true }),
-        rule(["markup.raw", "markup.raw.block"], markdown.code),
-        rule(["markup.raw.inline"], markdown.code, { background: theme.background.default }),
-        rule(["markup.link", "markup.link.url", "string.special", "string.special.url"], markdown.link, {
-            underline: true,
-        }),
-        rule(["markup.link.label"], markdown.linkText, { underline: true }),
-        rule(["label"], markdown.linkText),
-        rule(["spell", "nospell"], theme.text.default),
-        rule(["markup.underline"], theme.text.default, { underline: true }),
-        rule(["comment.error"], feedback.error.default, { italic: true, bold: true }),
-        rule(["comment.warning"], feedback.warning.default, { italic: true, bold: true }),
-        rule(["comment.todo", "comment.note"], feedback.info.default, { italic: true, bold: true }),
-        rule(["attribute", "annotation"], feedback.warning.default),
-        rule(["tag"], feedback.error.default),
-        rule(["markup.strikethrough", "markup.list.unchecked", "debug"], theme.text.subdued),
-        rule(["markup.list.checked"], feedback.success.default),
-        rule(["diff.plus"], theme.diff.text.added, { background: theme.diff.background.added }),
-        rule(["diff.minus"], theme.diff.text.removed, { background: theme.diff.background.removed }),
-        rule(["diff.delta"], theme.diff.text.context, { background: theme.diff.background.context }),
-        rule(["error"], feedback.error.default, { bold: true }),
-        rule(["warning"], feedback.warning.default, { bold: true }),
-        rule(["info"], feedback.info.default),
-    ]);
-}
-function rule(scope, foreground, style = {}) {
-    return { scope, style: { foreground, ...style } };
-}

package/dist/tui/types.d.ts

@@ -1,77 +0,0 @@
-import type { RGBA } from "@opentui/core";
-import type { ActionState, ActionVariant, BaseHue, FeedbackKind, HueAlias, HueStep, MarkdownToken, ContextKey, SyntaxToken } from "./schema.js";
-export type ResolvedActionState = "default" | ActionState;
-export type ResolvedFormfieldState = ResolvedActionState;
-export type HueScale = Readonly<Record<HueStep, RGBA>>;
-export type Hue = Readonly<Record<BaseHue | HueAlias, HueScale>>;
-export type HueSource = Readonly<{
-    hue: BaseHue | HueAlias;
-    step: HueStep;
-}>;
-export type Categorical = readonly HueScale[];
-export type StatefulColor = Readonly<Record<ResolvedActionState, RGBA>>;
-export type FormfieldColor = StatefulColor;
-export type ResolvedThemeView = {
-    readonly hue: Hue;
-    readonly categorical: Categorical;
-    readonly source: (color: RGBA) => HueSource | undefined;
-    readonly increase: (color: RGBA, amount?: number) => RGBA;
-    readonly decrease: (color: RGBA, amount?: number) => RGBA;
-    readonly text: {
-        readonly default: RGBA;
-        readonly subdued: RGBA;
-        readonly action: Readonly<Record<ActionVariant, StatefulColor>>;
-        readonly formfield: FormfieldColor;
-        readonly feedback: Readonly<Record<FeedbackKind, {
-            readonly default: RGBA;
-            readonly subdued: RGBA;
-        }>>;
-    };
-    readonly background: {
-        readonly default: RGBA;
-        readonly surface: {
-            readonly offset: RGBA;
-            readonly overlay: RGBA;
-        };
-        readonly action: Readonly<Record<ActionVariant, StatefulColor>>;
-        readonly formfield: FormfieldColor;
-        readonly feedback: Readonly<Record<FeedbackKind, {
-            readonly default: RGBA;
-        }>>;
-    };
-    readonly border: {
-        readonly default: RGBA;
-    };
-    readonly scrollbar: {
-        readonly default: RGBA;
-    };
-    readonly diff: {
-        readonly text: {
-            readonly added: RGBA;
-            readonly removed: RGBA;
-            readonly context: RGBA;
-            readonly hunkHeader: RGBA;
-        };
-        readonly background: {
-            readonly added: RGBA;
-            readonly removed: RGBA;
-            readonly context: RGBA;
-        };
-        readonly highlight: {
-            readonly added: RGBA;
-            readonly removed: RGBA;
-        };
-        readonly lineNumber: {
-            readonly text: RGBA;
-            readonly background: {
-                readonly added: RGBA;
-                readonly removed: RGBA;
-            };
-        };
-    };
-    readonly syntax: Readonly<Record<SyntaxToken, RGBA>>;
-    readonly markdown: Readonly<Record<MarkdownToken, RGBA>>;
-};
-export type ResolvedTheme = ResolvedThemeView & {
-    readonly contexts: Readonly<Partial<Record<ContextKey, ResolvedThemeView>>>;
-};

package/dist/tui/types.js

@@ -1 +0,0 @@
-export {};

package/dist/tui/v1-migrate.d.ts

@@ -1,3 +0,0 @@
-import type { ThemeDocument } from "./index.js";
-import type { ThemeV1Json } from "./v1.js";
-export declare function migrateV1(theme: ThemeV1Json): ThemeDocument;