@exponential_app/eui 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,76 @@
+import type { Easing, ResolvedTheme } from "./theme-types.js";
+export interface Keyframe {
+    offset: number;
+    opacity?: number;
+    translateX?: number;
+    translateY?: number;
+    rotate?: number;
+    scale?: number;
+    band?: number;
+}
+export interface AnimationDef {
+    duration: string;
+    factor: number;
+    easing: string;
+    iterations: number | `infinite`;
+    rest: number;
+    keyframes: Keyframe[];
+    band?: {
+        color: string;
+        stops: {
+            offset: number;
+            alpha: number;
+        }[];
+    };
+}
+/** The keyframe sets by name (style.json `animations`, `$comment` aside). */
+export declare const ANIMATIONS: Readonly<Record<string, AnimationDef>>;
+export declare const ANIMATION_NAMES: readonly string[];
+/** One frame: every channel at its value (`band` null = no shimmer band). */
+export interface AnimationFrame {
+    opacity: number;
+    translateX: number;
+    translateY: number;
+    rotate: number;
+    scale: number;
+    band: number | null;
+}
+export interface AnimationTiming {
+    durationMs: number;
+    /** A cubic bezier or `linear`. */
+    easing: Easing | `linear`;
+    iterations: number | `infinite`;
+}
+/** Duration and easing of an animation under a theme: the `duration` token
+ *  (or `durationToken`, the node's `animationDuration`) × `factor`. */
+export declare function animationTiming(name: string, theme: ResolvedTheme, durationToken?: string): AnimationTiming | null;
+/** y of a CSS cubic-bezier at x (bisection on x, 60 steps: deterministic). */
+export declare function cubicBezier(curve: Easing, x: number): number;
+/** The frame `elapsedMs` after the node entered the tree. Finished finite
+ *  animations hold their last keyframe; reduced motion = the `rest`
+ *  keyframe (no band). */
+export declare function animationFrame(name: string, elapsedMs: number, theme: ResolvedTheme, options?: {
+    reducedMotion?: boolean;
+    durationToken?: string;
+}): AnimationFrame | null;
+/** What a painter shows: the node's own opacity × the frame's (an
+ *  animation MULTIPLIES opacity; it never replaces it). */
+export declare function paintedOpacity(own: number | undefined, frame: AnimationFrame | null): number;
+/** The custom properties the keyframes animate, registered so they
+ *  interpolate: `--xui-a-opacity` (the animation's opacity factor; the node's
+ *  `opacity` = own × it, see css.ts styleToCss) and `--xui-band` (the shimmer
+ *  band). A CSS renderer adds this ONCE per document beside the keyframes. */
+export declare const ANIMATION_PROPERTIES_CSS = "@property --xui-a-opacity{syntax:\"<number>\";inherits:false;initial-value:1}@property --xui-band{syntax:\"<number>\";inherits:true;initial-value:1}";
+/** Whether a keyframe set animates opacity (its node's CSS opacity then
+ *  multiplies `--xui-a-opacity`). */
+export declare function animatesOpacity(name: string): boolean;
+/** The CSS `@keyframes xui-<name>` rule (individual `translate`/`rotate`/
+ *  `scale` properties compose OUTSIDE the node's own `transform`; opacity
+ *  moves `--xui-a-opacity`, which the node's `opacity` multiplies, so the
+ *  author's opacity survives the `both` fill; the shimmer band moves
+ *  `--xui-band`, which the renderer's overlay reads). Needs
+ *  `ANIMATION_PROPERTIES_CSS`. */
+export declare function keyframesCss(name: string): string;
+/** The CSS `animation` shorthand for a resolved timing (per-segment easing
+ *  is CSS's own semantics). */
+export declare function animationCss(name: string, timing: AnimationTiming): string;

package/dist/types/src/basic-map.d.ts

@@ -0,0 +1,38 @@
+import type { Action, ChildTemplate, FlatComponent } from "./types.js";
+interface PropRule {
+    from?: string;
+    map?: Record<string, unknown>;
+    default?: unknown;
+    const?: unknown;
+}
+interface ComponentRule {
+    to: string;
+    props: Record<string, string | PropRule>;
+    children?: `children` | `child`;
+    transform?: string;
+}
+export declare const basicMap: {
+    from: string;
+    to: string;
+    version: string;
+    placeholderIcon: string;
+    components: Record<string, ComponentRule>;
+    transforms: Record<string, string>;
+    icons: Record<string, string | null>;
+    functions: Record<string, string>;
+};
+/** What a basic component becomes before the reducer nests its children. */
+export interface MappedComponent {
+    component: string;
+    props: Record<string, unknown>;
+    childrenIds: string[];
+    template?: ChildTemplate;
+    slots: Record<string, string>;
+    on?: Record<string, Action>;
+    style?: Record<string, unknown>;
+}
+export declare function mapBasicIcon(name: unknown): string;
+/** Map one basic component; `null` when the table has no row (→ Unknown). */
+export declare function mapBasicComponent(flat: FlatComponent, lookup: (id: string) => FlatComponent | undefined): MappedComponent | null;
+export declare const BASIC_TRANSFORM_NAMES: readonly string[];
+export {};

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;