@riverbankcms/sdk 0.104.1 → 0.104.3

package/dist/_dts/theme-core/src/ThemeScope.d.ts

@@ -3,7 +3,7 @@ import type { Theme } from "./schema";
 import { type ThemeResponsiveMode } from "./responsiveMode";
 type Props = {
     theme: Theme;
-    children: React.ReactNode;
+    children?: React.ReactNode;
     themeId?: string;
     responsiveMode?: ThemeResponsiveMode;
     /** Additional className to apply to the theme-scope wrapper */

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

@@ -0,0 +1,29 @@
+/**
+ * Affordance icon path data for CSS-emitted button affordances.
+ *
+ * A button variant may declare a trailing `affordance` icon (see
+ * `ButtonVariantAffordance`). The generated button CSS renders that icon as a
+ * masked `::after` pseudo-element, so the personality supplies it to every
+ * button of the variant without per-node authoring.
+ *
+ * Icons live in the `@riverbankcms/blocks` registry, but the button CSS is
+ * generated here in theme-core, so this module carries a small, curated copy of
+ * the *affordance-eligible* icon path data (arrows/chevrons — the action-oriented
+ * subset). The `d` values below are duplicated verbatim from the matching entries
+ * in `blocks/src/system/icons/svg.tsx`; ids match the registry ids exactly so a
+ * node-level `trailingIcon` and a personality `affordance` share one id space.
+ *
+ * Keep this set intentionally tiny. It is not the full CTA icon set — only the
+ * shapes that read as a trailing affordance.
+ */
+/** Registry icon id → the SVG path `d` fragments composing that icon. */
+export declare const AFFORDANCE_ICON_PATHS: Readonly<Record<string, readonly string[]>>;
+export type AffordanceIconId = keyof typeof AFFORDANCE_ICON_PATHS;
+export declare function isAffordanceIconId(value: string): value is AffordanceIconId;
+/**
+ * Build a `data:image/svg+xml,...` URL for an affordance icon, suitable for use
+ * as a CSS `mask-image`. The stroke is painted solid black so the mask's alpha
+ * traces the icon outline; the visible colour is supplied separately by the
+ * `::after` rule's `background-color`. Returns `null` for unknown ids.
+ */
+export declare function affordanceIconMaskUrl(iconId: string): string | null;

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

@@ -1,5 +1,11 @@
 import type { Theme } from '../schema';
 import type { ButtonSystem } from './types';
+/**
+ * Class the `button` runtime node adds when it renders its own trailing icon,
+ * so a node-level icon suppresses the personality's CSS `::after` affordance
+ * (node overrides personality). Shared so generator and renderer can't drift.
+ */
+export declare const AFFORDANCE_SUPPRESS_CLASS = "rb-affordance-off";
 export interface GenerateButtonCssOptions {
     themeId: string;
     theme: Theme;

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

@@ -6,6 +6,7 @@
 export * from './types';
 export * from './classNames';
 export * from './generateButtonCss';
+export * from './affordanceIcons';
 export * from './generateDefaultButtonSystem';
 export * from './constants';
 export * from './presets';

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

@@ -0,0 +1,20 @@
+/**
+ * Flat Ink — a solid ink primary, a hairline ghost secondary, and a single
+ * amber accent climax, all completely flat (no drop shadow) with a modest
+ * radius. Reads as grounded, editorial and clinician-precise: the Fulcrum
+ * physiotherapy voice. The primary shifts to the secondary (moss) on hover and
+ * every variant lifts 2px; the amber accent is meant to be used sparingly as
+ * the page's one conversion climax.
+ */
+export declare const flatInk: Readonly<{
+    id: import("./types").ButtonPersonalityId<"flat-ink">;
+    name: string;
+    description: string;
+    tags: Readonly<Partial<Readonly<{
+        tone: import("../../../../blocks/src/index").StyleTone;
+        energy: import("../../../../blocks/src/index").StyleEnergy;
+        motion: import("../../../../blocks/src/index").StyleMotion;
+        era: import("../../../../blocks/src/index").StyleEra;
+    }>>>;
+    buttonSystem: import("../../../../blocks/src/index").ButtonSystem;
+}>;

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

@@ -75,6 +75,17 @@ export declare const buttonPersonalities: readonly [Readonly<{
         era: import("../../../../blocks/src/index").StyleEra;
     }>>>;
     buttonSystem: import("../../../../blocks/src/index").ButtonSystem;
+}>, Readonly<{
+    id: ButtonPersonalityId<"flat-ink">;
+    name: string;
+    description: string;
+    tags: Readonly<Partial<Readonly<{
+        tone: import("../../../../blocks/src/index").StyleTone;
+        energy: import("../../../../blocks/src/index").StyleEnergy;
+        motion: import("../../../../blocks/src/index").StyleMotion;
+        era: import("../../../../blocks/src/index").StyleEra;
+    }>>>;
+    buttonSystem: import("../../../../blocks/src/index").ButtonSystem;
 }>, Readonly<{
     id: ButtonPersonalityId<"brushed-wash">;
     name: string;

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

@@ -200,6 +200,10 @@ export declare const buttonPersonalitySchema: z.ZodObject<{
                     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<{

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

@@ -95,6 +95,26 @@ export interface ButtonBorder {
     widthClass: string;
     colorToken: string;
 }
+/**
+ * Optional trailing affordance icon carried by a button variant.
+ *
+ * When set, the generated button CSS emits a themed trailing icon (a masked
+ * SVG in `colorToken`, or `currentColor` when the token is omitted) after the
+ * label — so a personality can supply an affordance (e.g. a CTA arrow) to every
+ * button of that variant without per-node authoring. Entirely optional: variants
+ * that omit `affordance` are byte-identical to before.
+ *
+ * `iconId` references the shared icon registry (the same id space a `button`
+ * node's `trailingIcon` prop uses, e.g. `'ArrowRight'`). Only a small curated set
+ * of affordance-eligible ids is emittable as CSS (see `AFFORDANCE_ICON_PATHS`);
+ * unknown ids emit no icon.
+ */
+export interface ButtonVariantAffordance {
+    /** Registry icon id, e.g. `'ArrowRight'`. */
+    iconId: string;
+    /** Optional palette token for the icon colour. Omit to inherit the button text colour. */
+    colorToken?: string;
+}
 export declare const cornerStyleSchema: z.ZodEnum<{
     square: "square";
     rounded: "rounded";
@@ -329,6 +349,10 @@ export declare const buttonBorderSchema: z.ZodObject<{
     widthClass: z.ZodString;
     colorToken: z.ZodString;
 }, z.core.$strip>;
+export declare const buttonVariantAffordanceSchema: z.ZodObject<{
+    iconId: z.ZodString;
+    colorToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * Per-variant size overrides schema — every entry is optional.
  *
@@ -445,6 +469,10 @@ export declare const buttonVariantSchema: z.ZodObject<{
             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>;
 export declare const buttonSystemSchema: z.ZodObject<{
     global: z.ZodObject<{
@@ -595,6 +623,10 @@ export declare const buttonSystemSchema: z.ZodObject<{
                 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<{
@@ -711,6 +743,8 @@ export interface ButtonVariant {
     effects?: VariantEffects;
     /** Per-variant size overrides. See VariantSizeOverrides. */
     sizes?: VariantSizeOverrides;
+    /** Optional trailing affordance icon (e.g. a CTA arrow). See ButtonVariantAffordance. */
+    affordance?: ButtonVariantAffordance;
 }
 export interface ButtonSystem {
     global: ButtonGlobalSettings;