@exponential-at/ui 0.0.0-stage → 0.1.0

package/dist/types/src/builder.d.ts

@@ -0,0 +1,50 @@
+import type { ModeName, ResolvedTheme, Shadow, ThemeIssue, ThemeSource } from "./theme-types.js";
+/** shadcn / tweakcn variable → theme colour name. */
+export declare const SHADCN_COLOR_VARS: Record<string, string>;
+export interface ThemeImport {
+    modes: Partial<Record<ModeName, {
+        color: Record<string, `#${string}`>;
+        shadow?: Record<string, Shadow[]>;
+    }>>;
+    tokens: {
+        radius?: Record<string, number>;
+        type?: {
+            family?: Record<string, string>;
+        };
+    };
+    fonts: Record<string, {
+        fallback?: string;
+        source: `host`;
+    }>;
+    /** Variables the importer did not understand (`--sidebar`, `var()` refs…). */
+    unmapped: string[];
+}
+/** `0 1px 2px 0 hsl(0 0% 0% / 0.05), …` → layers; null when not parseable. */
+export declare function parseShadow(value: string): Shadow[] | null;
+/** A shadcn `globals.css` (v4 oklch, v3 bare-HSL triplets) or a tweakcn
+ *  export → the colours per mode, the radius ladder, the families and the
+ *  shadows it carried. Everything else is listed under `unmapped`. */
+export declare function importShadcnCss(css: string): ThemeImport;
+/** The import as a theme file. With a `base` it becomes an `extends` theme
+ *  carrying only what the CSS said; without one it is a root and the
+ *  caller fills the rest (the builder starts from a built-in anyway). */
+export declare function themeFromImport(imp: ThemeImport, meta: {
+    id: string;
+    name: string;
+    extends?: string;
+}): ThemeSource;
+/** The smallest theme that, extending `base`, resolves to `full`: only the
+ *  values that differ. Recipes pass through as the draft's own rules (they
+ *  are already overrides). */
+export declare function diffTheme(full: ResolvedTheme | ThemeSource, base: ResolvedTheme, meta?: {
+    id?: string;
+    name?: string;
+}): ThemeSource;
+/** Pretty JSON with `$schema` first, the export the builder downloads. */
+export declare function exportThemeJson(theme: ThemeSource): string;
+/** `JSON.parse` + load, never throwing: the builder's "paste a theme" path. */
+export declare function parseThemeJson(text: string, themes: readonly (ThemeSource | ResolvedTheme)[]): {
+    theme: ResolvedTheme | null;
+    source: ThemeSource | null;
+    issues: ThemeIssue[];
+};

package/dist/types/src/catalog.d.ts

@@ -0,0 +1,54 @@
+import type { CatalogSource, ComponentDef, DefSchema, ExtensionDef, MacroDef } from "./types.js";
+/** The runtime catalog: no descriptions or examples until `describeCatalog()`
+ *  (src/catalog.described.ts; the `./prompt` and `./schema` entries) attaches them. */
+export declare const coreCatalog: CatalogSource;
+/** `https://ui.exponential.at/catalogs/core/v1` */
+export declare const CORE_CATALOG_ID: string;
+/** The prompt-sized subset: the app-shaped vocabulary (no overlays, media,
+ *  Chart, data tables or the rarer controls). A lite surface is a valid core
+ *  surface, so it is a second id over the same definitions. */
+export declare const CORE_LITE_CATALOG_ID: string;
+/** The vendored A2UI basic catalog (vendor/a2ui/v0_9). */
+export declare const A2UI_BASIC_CATALOG_ID: string;
+/** The A2UI wire `version` the vendored schemas carry. */
+export declare const A2UI_VERSION: string;
+/** What a client sends as `supportedCatalogIds`. */
+export declare const SUPPORTED_CATALOG_IDS: readonly string[];
+export declare const UNKNOWN_COMPONENT: string;
+export declare const coreMacros: Record<string, MacroDef>;
+/** Token groups → names, flattened (`type.size`, not a nested object), so a
+ *  reference `$<group>.<name>` resolves by one lookup. */
+export declare const TOKEN_GROUPS: Record<string, readonly string[]>;
+/** `$spacing.md` → `{ group: "spacing", name: "md" }`, or null when it is not
+ *  a well-formed reference. */
+export declare function parseTokenRef(value: unknown): {
+    group: string;
+    name: string;
+} | null;
+/** True when the reference names a token group AND a name in it. */
+export declare function isKnownToken(value: unknown): boolean;
+export interface CatalogView {
+    components: Record<string, ComponentDef>;
+    enums: Record<string, readonly string[]>;
+    defs: Record<string, DefSchema>;
+    macros: Record<string, MacroDef>;
+}
+/** The core merged with the given extensions. Extension names never shadow a
+ *  core name (defineExtension refuses that), so a plain spread is exact. */
+export declare function catalogView(extensions?: readonly ExtensionDef[]): CatalogView;
+/** `catalogView`, built once per extension list and SHARED (VAPP-152: the
+ *  reducer and the macro expander asked for a fresh copy of every table on
+ *  each streamed `updateComponents`). Read-only; an empty list is the
+ *  core's. */
+export declare function sharedCatalogView(extensions?: readonly ExtensionDef[]): CatalogView;
+export declare function componentDef(name: string, extensions?: readonly ExtensionDef[]): ComponentDef | undefined;
+/** True for a component a model is offered: anything but the hidden
+ *  placeholder. */
+export declare function isOffered(def: ComponentDef): boolean;
+/** Component names in source order, optionally the lite subset, never the
+ *  hidden placeholder. */
+export declare function componentNames(options?: {
+    lite?: boolean;
+}): string[];
+/** The lite subset's names. */
+export declare function coreLite(): string[];

package/dist/types/src/catalog.described.d.ts

@@ -0,0 +1,33 @@
+import type { CatalogSource } from "./types.js";
+/** The text a prop schema carries (recursing into `items`). */
+export interface PropDescription {
+    description?: string;
+    items?: PropDescription;
+}
+/** The text of the catalog, keyed like the catalog itself. */
+export interface CatalogDescriptions {
+    components: Record<string, {
+        description?: string;
+        example?: Record<string, unknown>;
+        props: Record<string, PropDescription>;
+    }>;
+    defs: Record<string, {
+        description?: string;
+        properties: Record<string, PropDescription>;
+    }>;
+    functions: {
+        core: Record<string, string>;
+        basic: Record<string, string>;
+    };
+}
+/** The source catalog split into what the runtime needs and the text only
+ *  the prompt, the schema and the docs read. Pure: the source stays as it is. */
+export declare function splitDescriptions(source: CatalogSource): {
+    runtime: CatalogSource;
+    descriptions: CatalogDescriptions;
+};
+/** Puts the text back onto a runtime catalog, in place. */
+export declare function applyDescriptions(target: CatalogSource, descriptions: CatalogDescriptions): void;
+/** `coreCatalog` with its descriptions and examples attached (once per
+ *  process); what the prompt, the schema emitter and the docs read. */
+export declare function describeCatalog(): CatalogSource;