@riverbankcms/sdk 0.108.0 → 0.111.0

package/dist/_dts/theme-core/src/buttons/personalities/types.d.ts

@@ -1,273 +0,0 @@
-import { z } from 'zod';
-import { type ButtonSystem } from '../types';
-import { type StyleTags } from '../../site-styles/styleTags';
-/**
- * Branded ID for a button personality entry in the curated library.
- * Shape matches the `Brand<T, TBrand>` convention in `site-styles/types.ts`
- * (kept structurally compatible until that alias is hoisted to a shared file).
- * Use `asButtonPersonalityId` at the parse/construction boundary.
- */
-export type ButtonPersonalityId<T extends string = string> = T & {
-    readonly __brand: 'ButtonPersonalityId';
-};
-export declare function asButtonPersonalityId<const T extends string>(value: T): ButtonPersonalityId<T>;
-export declare const buttonPersonalityIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ButtonPersonalityId<string>, string>>;
-/**
- * A button personality is a complete `ButtonSystem` plus the tags that decide
- * which curated site styles will accept it. The `name` and `description` are
- * surfaced in the Style configurator UI.
- */
-export type ButtonPersonality<TId extends ButtonPersonalityId = ButtonPersonalityId> = Readonly<{
-    id: TId;
-    name: string;
-    description: string;
-    tags: StyleTags;
-    buttonSystem: ButtonSystem;
-}>;
-export declare const buttonPersonalitySchema: z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<ButtonPersonalityId<string>, string>>;
-    name: z.ZodString;
-    description: z.ZodString;
-    tags: z.ZodObject<{
-        tone: z.ZodOptional<z.ZodEnum<{
-            bold: "bold";
-            minimal: "minimal";
-            classic: "classic";
-        }>>;
-        energy: z.ZodOptional<z.ZodEnum<{
-            calm: "calm";
-            vibrant: "vibrant";
-        }>>;
-        motion: z.ZodOptional<z.ZodEnum<{
-            standard: "standard";
-            subtle: "subtle";
-            expressive: "expressive";
-        }>>;
-        era: z.ZodOptional<z.ZodEnum<{
-            editorial: "editorial";
-            modern: "modern";
-            retro: "retro";
-            technical: "technical";
-            organic: "organic";
-        }>>;
-    }, z.core.$strip>;
-    buttonSystem: z.ZodObject<{
-        global: z.ZodObject<{
-            cornerStyle: z.ZodEnum<{
-                square: "square";
-                rounded: "rounded";
-                pill: "pill";
-            }>;
-            cornerRadius: z.ZodOptional<z.ZodNumber>;
-            shadow: z.ZodOptional<z.ZodEnum<{
-                medium: "medium";
-                none: "none";
-                high: "high";
-                low: "low";
-            }>>;
-            textTransform: z.ZodEnum<{
-                none: "none";
-                lowercase: "lowercase";
-                uppercase: "uppercase";
-                capitalize: "capitalize";
-            }>;
-            fontWeight: z.ZodUnion<readonly [z.ZodLiteral<500>, z.ZodLiteral<600>, z.ZodLiteral<700>]>;
-            borderWidth: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-            typography: z.ZodOptional<z.ZodEnum<{
-                heading: "heading";
-                body: "body";
-            }>>;
-            fontSize: z.ZodOptional<z.ZodString>;
-            letterSpacing: z.ZodOptional<z.ZodEnum<{
-                tight: "tight";
-                normal: "normal";
-                loose: "loose";
-            }>>;
-            italic: z.ZodOptional<z.ZodBoolean>;
-            paddingPreset: z.ZodOptional<z.ZodEnum<{
-                default: "default";
-                compact: "compact";
-                spacious: "spacious";
-            }>>;
-            hoverTransform: z.ZodEnum<{
-                none: "none";
-                scale: "scale";
-                lift: "lift";
-                press: "press";
-            }>;
-            hoverColor: z.ZodEnum<{
-                none: "none";
-                token: "token";
-                brighten: "brighten";
-                darken: "darken";
-                saturate: "saturate";
-            }>;
-            hoverColorToken: z.ZodOptional<z.ZodString>;
-            gradientStyle: z.ZodOptional<z.ZodEnum<{
-                linear: "linear";
-                radial: "radial";
-                conic: "conic";
-            }>>;
-            gradientAngle: z.ZodOptional<z.ZodNumber>;
-            gradientSharpness: z.ZodOptional<z.ZodEnum<{
-                medium: "medium";
-                hard: "hard";
-                smooth: "smooth";
-            }>>;
-        }, z.core.$strip>;
-        variants: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            enabled: z.ZodBoolean;
-            priority: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-            background: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"solid">;
-                colorToken: z.ZodString;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"gradient">;
-                stops: z.ZodArray<z.ZodString>;
-                direction: z.ZodEnum<{
-                    "to-r": "to-r";
-                    "to-l": "to-l";
-                    "to-t": "to-t";
-                    "to-b": "to-b";
-                    "to-tr": "to-tr";
-                    "to-tl": "to-tl";
-                    "to-br": "to-br";
-                    "to-bl": "to-bl";
-                }>;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"transparent">;
-            }, z.core.$strip>], "type">;
-            textColorToken: z.ZodString;
-            borderRadius: z.ZodOptional<z.ZodString>;
-            shadow: z.ZodOptional<z.ZodObject<{
-                elevation: z.ZodEnum<{
-                    medium: "medium";
-                    none: "none";
-                    high: "high";
-                    low: "low";
-                }>;
-                softness: z.ZodNullable<z.ZodEnum<{
-                    crisp: "crisp";
-                    soft: "soft";
-                    hard: "hard";
-                }>>;
-                position: z.ZodDefault<z.ZodEnum<{
-                    bottom: "bottom";
-                    "bottom-right": "bottom-right";
-                }>>;
-                colorToken: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            border: z.ZodOptional<z.ZodObject<{
-                widthClass: z.ZodString;
-                colorToken: z.ZodString;
-            }, z.core.$strip>>;
-            hoverBackgroundToken: z.ZodOptional<z.ZodString>;
-            effects: z.ZodOptional<z.ZodObject<{
-                base: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-                hover: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-                active: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-                focus: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    effectId: z.ZodString;
-                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            sizes: z.ZodOptional<z.ZodObject<{
-                sm: z.ZodOptional<z.ZodObject<{
-                    padding: z.ZodString;
-                    fontSize: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-                md: z.ZodOptional<z.ZodObject<{
-                    padding: z.ZodString;
-                    fontSize: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-                lg: z.ZodOptional<z.ZodObject<{
-                    padding: z.ZodString;
-                    fontSize: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-                xl: z.ZodOptional<z.ZodObject<{
-                    padding: z.ZodString;
-                    fontSize: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-            affordance: z.ZodOptional<z.ZodObject<{
-                iconId: z.ZodString;
-                colorToken: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        sizes: z.ZodOptional<z.ZodPipe<z.ZodObject<{
-            sm: z.ZodObject<{
-                padding: z.ZodString;
-                fontSize: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
-            md: z.ZodObject<{
-                padding: z.ZodString;
-                fontSize: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
-            lg: z.ZodObject<{
-                padding: z.ZodString;
-                fontSize: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
-            xl: z.ZodOptional<z.ZodObject<{
-                padding: z.ZodString;
-                fontSize: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>, z.ZodTransform<{
-            sm: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-            md: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-            lg: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-            xl: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-        }, {
-            sm: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-            md: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-            lg: {
-                padding: string;
-                fontSize?: string | undefined;
-            };
-            xl?: {
-                padding: string;
-                fontSize?: string | undefined;
-            } | undefined;
-        }>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Helper for personality file modules to keep the call site short and
- * type-safe. `as const satisfies ...` would also work but produces wider
- * types at use sites.
- */
-export declare function defineButtonPersonality<const TId extends string>(input: {
-    id: TId;
-    name: string;
-    description: string;
-    tags: StyleTags;
-    buttonSystem: ButtonSystem;
-}): ButtonPersonality<ButtonPersonalityId<TId>>;

package/dist/_dts/theme-core/src/buttons/presets/types.d.ts

@@ -1,88 +0,0 @@
-import type { EffectReference } from '../effects/types';
-/**
- * Button background treatment types
- */
-export type ButtonBackground = {
-    type: 'solid';
-    colorToken: string;
-} | {
-    type: 'gradient';
-    stops: string[];
-    direction: GradientDirection;
-} | {
-    type: 'transparent';
-};
-/**
- * Gradient direction
- */
-export type GradientDirection = 'to-r' | 'to-l' | 'to-t' | 'to-b' | 'to-br' | 'to-bl' | 'to-tr' | 'to-tl';
-/**
- * Border radius options (Tailwind classes)
- */
-export type BorderRadius = 'rounded-none' | 'rounded-sm' | 'rounded' | 'rounded-md' | 'rounded-lg' | 'rounded-xl' | 'rounded-2xl' | 'rounded-3xl' | 'rounded-full';
-/**
- * Shadow options (Tailwind classes)
- */
-export type Shadow = 'shadow-none' | 'shadow-sm' | 'shadow' | 'shadow-md' | 'shadow-lg' | 'shadow-xl' | 'shadow-2xl';
-/**
- * Border width options (Tailwind classes)
- */
-export type BorderWidth = 'border' | 'border-2' | 'border-[3px]';
-/**
- * Button border configuration
- */
-export interface ButtonBorder {
-    widthClass: BorderWidth;
-    colorToken: string;
-}
-/**
- * Button preset - high-level button configuration
- *
- * A button preset defines the complete appearance of a button:
- * - Background treatment (solid/gradient using tokens)
- * - Text color, shape, shadow
- * - Composable effects for different states
- *
- * All colors use theme tokens so changing the palette updates all buttons.
- */
-export interface ButtonPreset {
-    /** Unique identifier */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Background treatment (uses theme tokens) */
-    background: ButtonBackground;
-    /** Text color token (e.g., 'white', 'text-900', 'primary-100') */
-    textColorToken: string;
-    /** Border radius (Tailwind class) */
-    borderRadius: BorderRadius;
-    /** Shadow (Tailwind class) */
-    shadow: Shadow;
-    /** Optional border */
-    border?: ButtonBorder;
-    /** Optional padding override (CSS shorthand, defaults to "0.5rem 1rem") */
-    padding?: string;
-    /** Optional font size override (Tailwind text size class like "text-sm", "text-base", "text-lg") */
-    fontSize?: string;
-    /**
-     * Composable effects for different states
-     *
-     * - base: Always applied (for persistent effects like cosmic glow)
-     * - hover: Applied on :hover
-     * - active: Applied on :active
-     * - focus: Applied on :focus
-     */
-    effects: {
-        base?: EffectReference[];
-        hover?: EffectReference[];
-        active?: EffectReference[];
-        focus?: EffectReference[];
-    };
-    /**
-     * Fields that users cannot change
-     *
-     * These are locked by the preset author to maintain design integrity.
-     * Examples: ['background', 'borderRadius', 'effects.base[0].preset']
-     */
-    lockedFields?: string[];
-}

package/dist/_dts/theme-core/src/buttons/utils/contrast.d.ts

@@ -1,38 +0,0 @@
-import type { Theme } from '../../schema';
-/**
- * Calculate contrast ratio between two colors
- * https://www.w3.org/TR/WCAG20/#contrast-ratiodef
- *
- * Returns a ratio from 1:1 (no contrast) to 21:1 (maximum contrast)
- * WCAG AA requires 4.5:1 for normal text, 3:1 for large text
- */
-export declare function getContrastRatio(hex1: string, hex2: string): number;
-/**
- * Check if contrast ratio meets WCAG AA standard (4.5:1)
- */
-export declare function hasGoodContrast(hex1: string, hex2: string): boolean;
-/**
- * Select appropriate text color based on background color and theme mode
- *
- * Logic:
- * - Light theme: Try white → text color → black
- * - Dark theme: Try background → text color → white
- *
- * Returns the color token name that has sufficient contrast
- */
-export declare function selectTextColorToken(backgroundHex: string, theme: Theme, isLightTheme: boolean): string;
-/**
- * Get contrasting text color for a button background
- *
- * This function returns theme-aware text colors using the neutral scale,
- * which is guaranteed to exist in every theme and harmonizes with the design.
- *
- * Uses neutral-50 (lightest) for dark backgrounds and neutral-950 (darkest)
- * for light backgrounds. This ensures excellent contrast while respecting
- * the theme's neutral palette (warm/cool tinting).
- *
- * For solid backgrounds with primary/secondary/neutral colors:
- * - Dark backgrounds (shade >= 500): neutral-50 (very light)
- * - Light backgrounds (shade < 500): neutral-950 (very dark)
- */
-export declare function getContrastingTextColorToken(backgroundToken: string, theme: Theme): string;

package/dist/_dts/theme-core/src/palette/themePaletteCompatibility.d.ts

@@ -1,57 +0,0 @@
-import { type PaletteTokenName } from '../tokens/themeColorTokens';
-import { type PaletteColors, type PaletteMode } from './colors';
-import type { PaletteOverrides } from './curated';
-/**
- * The persisted Theme palette boundary. It deliberately stays narrower than
- * the full Theme schema so consumers do not need to depend on another package
- * just to interpret current sparse palette entries.
- */
-export type ThemePaletteCompatibilityInput = Readonly<{
-    palette?: Readonly<{
-        colors: readonly Readonly<{
-            name: string;
-            hex: string;
-        }>[];
-        meta?: Readonly<{
-            mode?: unknown;
-        }> | null;
-    }> | null;
-}>;
-export type ThemePaletteCompatibilityError = Readonly<{
-    kind: 'missing-palette';
-}> | Readonly<{
-    kind: 'invalid-mode';
-}> | Readonly<{
-    kind: 'unknown-role';
-    role: string;
-}> | Readonly<{
-    kind: 'duplicate-role';
-    role: PaletteTokenName;
-}> | Readonly<{
-    kind: 'invalid-color';
-    role: PaletteTokenName;
-    value: string;
-}> | Readonly<{
-    kind: 'invalid-complete-palette';
-}>;
-export type CompatibleThemePalette = Readonly<{
-    kind: 'complete';
-    colors: PaletteColors;
-    mode: PaletteMode;
-}> | Readonly<{
-    kind: 'partial';
-    overrides: PaletteOverrides;
-    mode: PaletteMode;
-}>;
-export type ParseCompatibleThemePaletteResult = Readonly<{
-    ok: true;
-    palette: CompatibleThemePalette;
-}> | Readonly<{
-    ok: false;
-    error: ThemePaletteCompatibilityError;
-}>;
-/**
- * Parses current complete Theme palettes and sparse editor payloads. Historical
- * migration-only completion lives in historicalThemePalette.ts.
- */
-export declare function parseCompatibleThemePalette(theme: ThemePaletteCompatibilityInput): ParseCompatibleThemePaletteResult;