@riverbankcms/sdk 0.109.0 → 0.118.0

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

@@ -0,0 +1,80 @@
+import type { z } from 'zod';
+import type { StyleTags } from '../../site-styles/styleTags';
+import type { ButtonGlobalSettings, ButtonSizes, ButtonSystem, ButtonVariant } from '../types';
+export declare const PUBLIC_BUTTON_ROLES: readonly ["primary", "secondary", "outline", "ghost", "accent"];
+export type PublicButtonRole = (typeof PUBLIC_BUTTON_ROLES)[number];
+export type CompleteButtonRole = 'primary' | 'secondary';
+export type SupportingButtonRole = Exclude<PublicButtonRole, CompleteButtonRole>;
+export type ButtonVariantAppearance = Readonly<Pick<ButtonVariant, 'background' | 'borderRadius' | 'shadow' | 'border' | 'hoverBackgroundToken' | 'effects' | 'sizes' | 'affordance'>>;
+export type PublicButtonVariant<TRole extends PublicButtonRole = PublicButtonRole> = Omit<ButtonVariant, 'id' | 'enabled'> & Readonly<{
+    id: TRole;
+    enabled: true;
+}>;
+export type CompleteButtonRoles = Readonly<{
+    [TRole in PublicButtonRole]: PublicButtonVariant<TRole>;
+}>;
+type CompleteRoleDefinition<TRole extends PublicButtonRole> = Readonly<{
+    kind: 'complete';
+    appearance: ButtonVariantAppearance;
+}>;
+type DerivedRoleDefinition = Readonly<{
+    kind: 'derive';
+    from: CompleteButtonRole;
+    overrides?: Partial<ButtonVariantAppearance>;
+}>;
+export type ButtonRoleDefinitions = Readonly<{
+    primary: CompleteRoleDefinition<'primary'>;
+    secondary: CompleteRoleDefinition<'secondary'>;
+    outline: CompleteRoleDefinition<'outline'> | DerivedRoleDefinition;
+    ghost: CompleteRoleDefinition<'ghost'> | DerivedRoleDefinition;
+    accent: CompleteRoleDefinition<'accent'> | DerivedRoleDefinition;
+}>;
+export type ButtonStyleSystemDefinition = Readonly<{
+    global: ButtonGlobalSettings;
+    sizes?: ButtonSizes;
+    roles: ButtonRoleDefinitions;
+}>;
+type StringParameterKey<TParameters> = Extract<keyof TParameters, string>;
+export type ButtonStyleControl<TParameters> = {
+    [TKey in StringParameterKey<TParameters>]: Readonly<{
+        kind: 'choice';
+        parameter: TKey;
+        label: string;
+        options: readonly Readonly<{
+            value: Extract<TParameters[TKey], string>;
+            label: string;
+        }>[];
+    }>;
+}[StringParameterKey<TParameters>];
+export type ButtonStyleRecipe<TId extends string = string, TParameters = Readonly<Record<string, never>>> = Readonly<{
+    id: TId;
+    accessibilityLabel: string;
+    tags: StyleTags;
+    parameterSchema: z.ZodType<TParameters>;
+    defaultParameters: TParameters;
+    controls: readonly ButtonStyleControl<TParameters>[];
+    defineSystem: (parameters: TParameters) => ButtonStyleSystemDefinition;
+}>;
+export type ResolveButtonStyleError = Readonly<{
+    kind: 'invalid-parameters';
+    styleId: string;
+    issues: readonly string[];
+}> | Readonly<{
+    kind: 'invalid-button-system';
+    styleId: string;
+    issues: readonly string[];
+}>;
+export type ResolveButtonStyleResult = Readonly<{
+    kind: 'resolved';
+    buttonSystem: ButtonSystem;
+}> | Readonly<{
+    kind: 'error';
+    error: ResolveButtonStyleError;
+}>;
+export declare function defineButtonStyleRecipe<const TId extends string, TParameters>(recipe: ButtonStyleRecipe<TId, TParameters>): ButtonStyleRecipe<TId, TParameters>;
+export declare function materializeButtonRoles(definitions: ButtonRoleDefinitions): CompleteButtonRoles;
+export declare function resolveButtonStyleRecipe<TId extends string, TParameters>(recipe: ButtonStyleRecipe<TId, TParameters>, parameters: unknown): ResolveButtonStyleResult;
+export declare function isPublicButtonRole(value: string): value is PublicButtonRole;
+export declare function hasCompletePublicButtonRoles(buttonSystem: ButtonSystem): boolean;
+export declare function listMissingPublicButtonRoles(buttonSystem: ButtonSystem): readonly PublicButtonRole[];
+export {};

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

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './registry';
+export * from './selection';

package/dist/_dts/theme-core/src/buttons/styles/recipes/defineStaticButtonStyleRecipe.d.ts

@@ -0,0 +1,49 @@
+import { type ButtonColourTreatment, type ButtonGlobalSettings } from '../../types';
+import { type ButtonVariantAppearance, type ButtonStyleRecipe, type ButtonStyleSystemDefinition } from '../domain';
+type AuthoringColourTreatment = Readonly<{
+    type: 'solid';
+    colorToken: string;
+}> | Readonly<{
+    type: 'gradient';
+    stops: readonly [string, string, ...string[]];
+    direction: Extract<ButtonColourTreatment, {
+        type: 'gradient';
+    }>['direction'];
+    foregroundToken: string;
+}> | Extract<ButtonColourTreatment, {
+    type: 'surface';
+}>;
+type AuthoringAppearance = Omit<ButtonVariantAppearance, 'background' | 'hoverBackgroundToken'> & Readonly<{
+    background: AuthoringColourTreatment;
+    hoverBackgroundToken?: string;
+}>;
+type AuthoringCompleteRole = Readonly<{
+    kind: 'complete';
+    appearance: AuthoringAppearance;
+}>;
+type AuthoringDerivedRole = Readonly<{
+    kind: 'derive';
+    from: 'primary' | 'secondary';
+    overrides?: Partial<AuthoringAppearance>;
+}>;
+type AuthoringRoleDefinitions = Readonly<{
+    primary: AuthoringCompleteRole;
+    secondary: AuthoringCompleteRole;
+    outline: AuthoringCompleteRole | AuthoringDerivedRole;
+    ghost: AuthoringCompleteRole | AuthoringDerivedRole;
+    accent: AuthoringCompleteRole | AuthoringDerivedRole;
+}>;
+type AuthoringGlobalSettings = Omit<ButtonGlobalSettings, 'hoverColorToken'> & Readonly<{
+    hoverColorToken?: string;
+}>;
+export declare function defineStaticButtonStyleRecipe<const TId extends string>(input: {
+    id: TId;
+    accessibilityLabel: string;
+    tags: ButtonStyleRecipe<TId>['tags'];
+    system: Readonly<{
+        global: AuthoringGlobalSettings;
+        sizes?: ButtonStyleSystemDefinition['sizes'];
+        roles: AuthoringRoleDefinitions;
+    }>;
+}): ButtonStyleRecipe<TId>;
+export {};

package/dist/_dts/theme-core/src/buttons/styles/recipes/quietArrow.d.ts

@@ -0,0 +1,67 @@
+export declare const quietArrowRecipe: Readonly<{
+    id: "quiet-arrow";
+    accessibilityLabel: 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;
+    }>>>;
+    parameterSchema: import("zod").ZodType<{
+        secondaryTreatment: "outlined" | "solid-accent";
+    }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+        secondaryTreatment: "outlined" | "solid-accent";
+    }, unknown>>;
+    defaultParameters: {
+        secondaryTreatment: "outlined" | "solid-accent";
+    };
+    controls: readonly Readonly<{
+        kind: "choice";
+        parameter: "secondaryTreatment";
+        label: string;
+        options: readonly Readonly<{
+            value: "outlined" | "solid-accent";
+            label: string;
+        }>[];
+    }>[];
+    defineSystem: (parameters: {
+        secondaryTreatment: "outlined" | "solid-accent";
+    }) => Readonly<{
+        global: import("../../../../../blocks/src/index").ButtonGlobalSettings;
+        sizes?: import("../..").ButtonSizes;
+        roles: Readonly<{
+            primary: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }>;
+            secondary: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }>;
+            outline: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }> | Readonly<{
+                kind: "derive";
+                from: import("..").CompleteButtonRole;
+                overrides?: Partial<import("..").ButtonVariantAppearance>;
+            }>;
+            ghost: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }> | Readonly<{
+                kind: "derive";
+                from: import("..").CompleteButtonRole;
+                overrides?: Partial<import("..").ButtonVariantAppearance>;
+            }>;
+            accent: Readonly<{
+                kind: "complete";
+                appearance: import("..").ButtonVariantAppearance;
+            }> | Readonly<{
+                kind: "derive";
+                from: import("..").CompleteButtonRole;
+                overrides?: Partial<import("..").ButtonVariantAppearance>;
+            }>;
+        }>;
+    }>;
+}>;