@hex-core/registry

export interface Theme {
	name: string;
	displayName: string;
	description: string;
	tokens: {
		light: Record<string, TokenValue>;
		dark: Record<string, TokenValue>;
	};
	brand?: string;
	category?: ThemeCategory;
	tags?: string[];
	designBrief?: string;
	attribution?: ThemeAttribution; // see Theme classification surface entry below
}

import type { Theme } from "@hex-core/registry";

const myTheme: Theme = {
	name: "brand",
	displayName: "Brand",
	description: "Brand description",
	tokens: { light: {/* ... */}, dark: {/* ... */} },
};

export interface TokenValue {
	value: string;
	description?: string;
	type:
		| "number" | "color" | "dimension" | "font" | "fontWeight"
		| "duration" | "cubicBezier" | "shadow" | "gradient"
		| "radius" | "spacing" | "opacity";
}

export type TokenSet = Record<string, TokenValue>;

import type { TokenValue } from "@hex-core/registry";

const primary: TokenValue = { value: "240 5.9% 10%", type: "color" };
const radius: TokenValue = { value: "0.5rem", type: "radius" };

export interface RegistryItem {
	$schema: string;            // schema URL (defaulted)
	name: string;
	displayName: string;
	description: string;
	category:
		| "component" | "lib" | "hook" | "primitive"
		| "block" | "example" | "theme" | "ai";
	subcategory?: string;
	version: string;            // semver (defaulted to "0.0.1")
	framework: "react" | "vue" | "svelte"; // defaulted to "react"
	props: PropDef[];
	variants: VariantDef[];
	slots: SlotDef[];
	files: RegistryFile[];      // required — source files shipped by hex add
	dependencies: { npm: string[]; internal: string[]; peer: string[] };
	tokensUsed: string[];
	cssVariables?: Record<string, { light: string; dark: string }>;
	examples: Example[];
	ai: AIHints;
	tags: string[];
}

import { registryItemSchema } from "@hex-core/registry";

const parsed = registryItemSchema.parse(rawJson);
// → typed RegistryItem with full validation

import { strictThemeSchema, strictTokenSetSchema } from "@hex-core/registry";
import type { z } from "zod";

declare const strictThemeSchema: z.ZodType<Theme>;
declare const strictTokenSetSchema: z.ZodType<TokenSet>;

import { strictThemeSchema } from "@hex-core/registry";

const result = strictThemeSchema.safeParse(input);
if (!result.success) {
	throw new Error("Invalid theme: " + result.error.message);
}
const theme = result.data;

import {
	themeAttributionSchema,
	themeCategorySchema,
	type ThemeAttribution,
	type ThemeCategory,
} from "@hex-core/registry";

type ThemeCategory =
	| "ai" | "dev-tools" | "backend" | "productivity"
	| "design" | "fintech" | "ecommerce" | "media" | "automotive";

interface ThemeAttribution {
	source: string;       // e.g. "voltagent/awesome-design-md"
	license: string;      // SPDX identifier
	url: string;          // upstream URL
	brand?: string;       // brand name if applicable
}

import { themeCategorySchema, themeAttributionSchema } from "@hex-core/registry";

const cat = themeCategorySchema.parse("fintech"); // → "fintech"
const att = themeAttributionSchema.parse({
	source: "voltagent/awesome-design-md",
	license: "MIT",
	url: "https://github.com/voltagent/awesome-design-md",
	brand: "Stripe",
});

import { heavyPeerSchema, type HeavyPeer } from "@hex-core/registry";

interface HeavyPeer {
	name: string;          // npm package name (e.g. "@tanstack/react-table")
	version: string;       // semver range
	bundleKbGzip?: number; // estimated install cost surfaced by the CLI prompt
	reason?: string;       // human-readable why-this-peer note
}

// Components declare heavy peers via dependencies.heavyPeer[] in their schema:
declare const dependencySchema: z.ZodObject<{
	npm: string[];
	internal: string[];
	peer: string[];
	heavyPeer?: HeavyPeer[];
}>;

import { heavyPeerSchema } from "@hex-core/registry";

const peer = heavyPeerSchema.parse({
	name: "@tanstack/react-table",
	version: "^8.0.0 || ^9.0.0",
	bundleKbGzip: 28,
	reason: "Headless table primitives for sortable / filterable rows.",
});

import {
	recipeSchema,
	recipeSchemaDefinition,
	recipeStepSchema,
	recipeChecklistItemSchema,
	recipeIndexItemSchema,
	type Recipe,
	type RecipeStep,
	type RecipeChecklistItem,
	type RecipeIndex,
	type RecipeIndexItem,
	SLUG_REGEX,
	internalDepToSlug,
} from "@hex-core/registry";

interface Recipe {
	slug: string;
	title: string;
	summary: string;
	tags: string[];
	brief: string;
	steps: RecipeStep[];
	checklist: RecipeChecklistItem[];
	example?: string;
	tokenBudget?: number;
}

import { recipeSchema, internalDepToSlug } from "@hex-core/registry";

const recipe = recipeSchema.parse(rawJson);
console.log(recipe.steps.map((s) => s.component));
// → ["button", "input", "label", ...]

const slug = internalDepToSlug("primitives/button/button"); // → "button"

import {
	componentSchemaDefinition,
	type ComponentSchemaDefinition,
} from "@hex-core/registry";

declare const componentSchemaDefinition: z.ZodType<ComponentSchemaDefinition>;

import { componentSchemaDefinition } from "@hex-core/registry";
import { buttonSchema } from "@hex-core/components/schemas";

const def = componentSchemaDefinition.parse(buttonSchema);
console.log(def.variants);

import { strictThemeSchema } from "@hex-core/registry";
import { themeToCss } from "@hex-core/tokens";

export async function compileUploadedTheme(json: unknown) {
	const result = strictThemeSchema.safeParse(json);
	if (!result.success) {
		return { ok: false, errors: result.error.issues };
	}
	return { ok: true, css: themeToCss(result.data) };
}

import type { RegistryItem } from "@hex-core/registry";

export function makeRegistryItem(name: string): RegistryItem {
	return {
		$schema: "https://hex-ui.dev/schemas/registry-item.json",
		name,
		displayName: name,
		description: "TODO",
		category: "component",
		version: "0.0.1",
		framework: "react",
		props: [],
		variants: [],
		slots: [],
		files: [],
		examples: [],
		ai: {
			whenToUse: "",
			whenNotToUse: "",
			commonMistakes: [],
			relatedComponents: [],
			accessibilityNotes: "",
			tokenBudget: 0,
		},
		dependencies: { npm: [], internal: [], peer: [] },
		tokensUsed: [],
		tags: [],
	};
}