@riverbankcms/sdk 0.60.0 → 0.60.3

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

@@ -1,19 +1,24 @@
 import type { Theme } from '../schema';
 import type { ButtonSystem } from './types';
-/**
- * Generate complete CSS for button system from theme config
- *
- * This function:
- * 1. Reads button variants from theme.buttons
- * 2. Generates CSS for each variant
- * 3. Returns scoped CSS string
- *
- * Runs SERVER-SIDE during theme loading.
- * NOTE: Renderer only knows about theme config, NOT presets.
- */
 export interface GenerateButtonCssOptions {
     themeId: string;
     theme: Theme;
     buttonSystem?: ButtonSystem;
 }
+/**
+ * Generate complete CSS for a button system.
+ *
+ * Pipeline:
+ *   1. Resolve effective sizes (theme.sizes ∪ defaults)
+ *   2. For each enabled variant, produce a list of `CssChunk`s (typed rules
+ *      + opaque effect CSS)
+ *   3. Emit a `.default` alias from the highest-priority variant
+ *   4. Serialise the whole list to a CSS string
+ *
+ * Padding/fontSize at size S resolve in order:
+ *   variant.sizes?.[S] → theme.buttons.sizes?.[S] → DEFAULT_BUTTON_SIZES[S]
+ *
+ * 2-class selector specificity (`.{id}.btn-{S}`) carries the size override;
+ * no `!important` required.
+ */
 export declare function generateButtonCss(options: GenerateButtonCssOptions): string;

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

@@ -1,30 +1,23 @@
 import type { Theme } from '../schema';
 import type { ButtonSystem } from './types';
 /**
- * Map motion level to transition duration (milliseconds)
- * Used in effect generation
- */
-export declare const MOTION_TO_DURATION_MAP: Record<string, string>;
-/**
- * Map motion easing to CSS easing function
- */
-export declare const MOTION_TO_EASING_MAP: Record<string, string>;
-/**
- * Generate default button system from theme settings
+ * Generate default button system from theme settings.
  *
- * Creates 4 standard button variants when theme.buttons is not defined:
+ * Creates 4 sized variants when theme.buttons is not defined:
  * 1. Primary - primary color background with opacity-reduce hover effect
  * 2. Secondary - neutral-700 background with opacity-reduce hover effect
  * 3. Outline - transparent background with primary border and opacity-reduce hover effect
  * 4. Ghost - transparent background, no border, with opacity-reduce hover effect
  *
- * All variants use theme settings for:
- * - Border radius (from theme.components.button.shape / theme.corners)
- * - Shadow (from theme.shadow.elevation)
+ * All four are sized variants — they inherit padding/fontSize from the theme's
+ * `sizes` config (or the system defaults) so they're consistent at any size.
+ *
+ * Variants use theme settings for:
+ * - Border radius (via global.cornerStyle / theme.corners)
+ * - Shadow (via global.shadow / theme.shadow.elevation)
  * - Border width for outline (from theme.border.width)
- * - Transitions (from theme.motion)
  *
  * @param theme - Theme configuration
- * @returns ButtonSystem with 4 default variants
+ * @returns ButtonSystem with 4 default sized variants
  */
 export declare function generateDefaultButtonSystem(theme: Theme): ButtonSystem;

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

@@ -8,6 +8,7 @@ export * from './generateButtonCss';
 export * from './generateDefaultButtonSystem';
 export * from './constants';
 export * from './presets';
+export * from './personalities';
 export * from './effects/types';
 export * from './effects/registry';
 export * from './effects/presets/transform';

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

@@ -0,0 +1,11 @@
+/**
+ * Brushed Wash — gradient backgrounds that read as watercolour washes.
+ * Generous padding, soft shadows; pairs with vibrant organic brands.
+ */
+export declare const brushedWash: Readonly<{
+    id: import("./types").ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: import("../../site-styles").StyleTags;
+    buttonSystem: import("@riverbankcms/blocks").ButtonSystem;
+}>;

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

@@ -0,0 +1,11 @@
+/**
+ * Confident Chip — moderate-radius solid buttons that read as competent and
+ * direct. Default for Clear Professional; works for any modern brand voice.
+ */
+export declare const confidentChip: Readonly<{
+    id: import("./types").ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: import("../../site-styles").StyleTags;
+    buttonSystem: import("@riverbankcms/blocks").ButtonSystem;
+}>;

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

@@ -0,0 +1,11 @@
+/**
+ * Editorial Link — all variants are link-style with a growing underline.
+ * Default for Warm Editorial and Quiet Luxury; reads as refined and quiet.
+ */
+export declare const editorialLink: Readonly<{
+    id: import("./types").ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: import("../../site-styles").StyleTags;
+    buttonSystem: import("@riverbankcms/blocks").ButtonSystem;
+}>;

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

@@ -0,0 +1,14 @@
+/**
+ * Button personality library.
+ *
+ * Each personality is a complete `ButtonSystem` tagged on the four style axes
+ * (tone / energy / motion / era). Curated site styles declare a default
+ * personality + an acceptance region that filters the picker; the Style
+ * configurator UI uses `compatibleEntries` from `site-styles/compatibility.ts`
+ * to surface valid options.
+ */
+import type { ButtonPersonality, ButtonPersonalityId } from './types';
+export type { ButtonPersonality, ButtonPersonalityId } from './types';
+export { asButtonPersonalityId, buttonPersonalityIdSchema, buttonPersonalitySchema, defineButtonPersonality, } from './types';
+export declare const buttonPersonalities: readonly ButtonPersonality[];
+export declare function findButtonPersonality(id: ButtonPersonalityId): ButtonPersonality | undefined;

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

@@ -0,0 +1,11 @@
+/**
+ * Ink Stamp — solid earthy fills with a bordered, hand-stamped block-print
+ * feel. Reads as bold and handmade; suits expressive craft brands.
+ */
+export declare const inkStamp: Readonly<{
+    id: import("./types").ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: import("../../site-styles").StyleTags;
+    buttonSystem: import("@riverbankcms/blocks").ButtonSystem;
+}>;

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

@@ -0,0 +1,11 @@
+/**
+ * Pebble — large pill primaries with generous padding. Reads as spa-luxurious
+ * and natural; pairs well with wellness/yoga/dance brands.
+ */
+export declare const pebble: Readonly<{
+    id: import("./types").ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: import("../../site-styles").StyleTags;
+    buttonSystem: import("@riverbankcms/blocks").ButtonSystem;
+}>;

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

@@ -0,0 +1,11 @@
+/**
+ * Soft Pill — rounded-full pill buttons with a hover lift. The default for
+ * Calm Studio and Modern Wellness; reads as quietly modern and welcoming.
+ */
+export declare const softPill: Readonly<{
+    id: import("./types").ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: import("../../site-styles").StyleTags;
+    buttonSystem: import("@riverbankcms/blocks").ButtonSystem;
+}>;

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

@@ -0,0 +1,268 @@
+import { z } from 'zod';
+import { type ButtonSystem } from '../types';
+import { type StyleTags } from '../../site-styles/compatibility';
+/**
+ * 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 = string & {
+    readonly __brand: 'ButtonPersonalityId';
+};
+export declare function asButtonPersonalityId(value: string): ButtonPersonalityId;
+export declare const buttonPersonalityIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ButtonPersonalityId, 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 = Readonly<{
+    id: ButtonPersonalityId;
+    name: string;
+    description: string;
+    tags: StyleTags;
+    buttonSystem: ButtonSystem;
+}>;
+export declare const buttonPersonalitySchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<ButtonPersonalityId, string>>;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodObject<{
+        tone: z.ZodOptional<z.ZodEnum<{
+            classic: "classic";
+            bold: "bold";
+            minimal: "minimal";
+        }>>;
+        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<{
+                rounded: "rounded";
+                square: "square";
+                pill: "pill";
+            }>;
+            cornerRadius: z.ZodOptional<z.ZodNumber>;
+            shadow: z.ZodEnum<{
+                medium: "medium";
+                none: "none";
+                low: "low";
+                high: "high";
+            }>;
+            textTransform: z.ZodEnum<{
+                none: "none";
+                capitalize: "capitalize";
+                lowercase: "lowercase";
+                uppercase: "uppercase";
+            }>;
+            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<{
+                body: "body";
+                heading: "heading";
+            }>>;
+            fontSize: z.ZodOptional<z.ZodString>;
+            letterSpacing: z.ZodOptional<z.ZodEnum<{
+                normal: "normal";
+                loose: "loose";
+                tight: "tight";
+            }>>;
+            italic: z.ZodOptional<z.ZodBoolean>;
+            paddingPreset: z.ZodOptional<z.ZodEnum<{
+                compact: "compact";
+                spacious: "spacious";
+                default: "default";
+            }>>;
+            hoverTransform: z.ZodEnum<{
+                none: "none";
+                scale: "scale";
+                lift: "lift";
+                press: "press";
+            }>;
+            hoverColor: z.ZodEnum<{
+                none: "none";
+                token: "token";
+                darken: "darken";
+                brighten: "brighten";
+                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";
+                smooth: "smooth";
+                hard: "hard";
+            }>>;
+        }, 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";
+                    low: "low";
+                    high: "high";
+                }>;
+                softness: z.ZodNullable<z.ZodEnum<{
+                    soft: "soft";
+                    crisp: "crisp";
+                    hard: "hard";
+                }>>;
+                position: z.ZodDefault<z.ZodEnum<{
+                    bottom: "bottom";
+                    "bottom-right": "bottom-right";
+                }>>;
+            }, 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>>;
+        }, 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(input: {
+    id: string;
+    name: string;
+    description: string;
+    tags: StyleTags;
+    buttonSystem: ButtonSystem;
+}): ButtonPersonality;