@riverbankcms/sdk 0.85.0 → 0.89.1

package/dist/_dts/blocks/src/system/blocks/newsletter-signup-destination.d.ts

@@ -0,0 +1,300 @@
+import type { Brand } from '../../../../core/src/index';
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+declare const serverResolvedMailchimpConnectionStateBrand: unique symbol;
+declare const serverValidatedMailchimpAudienceCompatibilityBrand: unique symbol;
+export type NewsletterListId = Brand<string, 'NewsletterListId'>;
+export type MailchimpConnectionId = Brand<string, 'MailchimpConnectionId'>;
+export type MailchimpAudienceId = Brand<string, 'MailchimpAudienceId'>;
+export type MailchimpTagName = Brand<string, 'MailchimpTagName'>;
+export type NewsletterSignupBlockId = Brand<string, 'NewsletterSignupBlockId'>;
+export type SignedNewsletterDestinationRef = Brand<string, 'SignedNewsletterDestinationRef'>;
+export type NewsletterSignupDestinationProvider = 'riverbank' | 'mailchimp';
+export type NewsletterSignupFieldPreset = 'emailOnly' | 'emailName' | 'emailFirstLast' | 'emailNameCompany';
+export type RiverbankNewsletterDestination = Readonly<{
+    tag: 'riverbank_list';
+    listId: NewsletterListId;
+}>;
+export type MailchimpNewsletterDestination = Readonly<{
+    tag: 'mailchimp_audience';
+    connectionId: MailchimpConnectionId;
+    audienceId: MailchimpAudienceId;
+    tags: readonly MailchimpTagName[];
+}>;
+export type NewsletterSignupAuthoringDestination = RiverbankNewsletterDestination | MailchimpNewsletterDestination;
+export type NewsletterSignupPublicDestinationRef = Readonly<{
+    tag: 'block_ref';
+    blockId: NewsletterSignupBlockId;
+}> | Readonly<{
+    tag: 'signed_destination_ref';
+    token: SignedNewsletterDestinationRef;
+}>;
+export type NewsletterSignupRawAuthoringContent = Readonly<{
+    destination?: unknown;
+    destinationProvider?: unknown;
+    listId?: unknown;
+    tags?: unknown;
+    mailchimpAudienceId?: unknown;
+    mailchimpTags?: unknown;
+}>;
+export type NewsletterSignupAuthoringState = Readonly<{
+    destination: NewsletterSignupAuthoringDestination;
+}>;
+export type NewsletterSignupDestinationEditorFieldState = Readonly<{
+    tag: 'riverbank';
+    showNewsletterList: true;
+    showRiverbankTags: true;
+    showMailchimpAudience: false;
+    showMailchimpTags: false;
+    showMailchimpConnectionWarning: false;
+}> | Readonly<{
+    tag: 'mailchimp';
+    showNewsletterList: false;
+    showRiverbankTags: false;
+    showMailchimpAudience: true;
+    showMailchimpTags: true;
+    showMailchimpConnectionWarning: boolean;
+}>;
+export type NewsletterSignupEditorValues = Readonly<{
+    destinationProvider?: unknown;
+    listId?: unknown;
+    tags?: unknown;
+    mailchimpAudienceId?: unknown;
+    mailchimpTags?: unknown;
+}>;
+export type NormalizedNewsletterSignupEditorValues = Readonly<{
+    destinationProvider: 'riverbank';
+    listId?: unknown;
+    tags?: unknown;
+}> | Readonly<{
+    destinationProvider: 'mailchimp';
+    mailchimpAudienceId?: unknown;
+    mailchimpTags?: unknown;
+}>;
+export type TrustedNewsletterSignupAuthoringDestinationError = Readonly<{
+    tag: 'invalid_destination_provider';
+    value: unknown;
+}> | Readonly<{
+    tag: 'riverbank_list_required';
+}> | Readonly<{
+    tag: 'mailchimp_connection_required';
+}> | Readonly<{
+    tag: 'mailchimp_connection_needs_reauth';
+}> | Readonly<{
+    tag: 'mailchimp_audience_required';
+}> | Readonly<{
+    tag: 'mailchimp_compatibility_validation_pending';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_tags';
+}> | Readonly<{
+    tag: 'mailchimp_audience_incompatible';
+    issues: readonly MailchimpAudienceCompatibilityIssue[];
+}>;
+export type TrustedNewsletterSignupAuthoringDestinationResult = Readonly<{
+    success: true;
+    destination: NewsletterSignupAuthoringDestination;
+}> | Readonly<{
+    success: false;
+    error: TrustedNewsletterSignupAuthoringDestinationError;
+}>;
+export type NewsletterSignupRuntimeSource = Readonly<{
+    destinationProvider: NewsletterSignupDestinationProvider;
+    listId: string | null;
+    tags: string | null;
+}>;
+export type MailchimpConnectionEditorState = Readonly<{
+    tag: 'not_connected';
+}> | Readonly<{
+    tag: 'connected';
+    connectionId: MailchimpConnectionId;
+}> | Readonly<{
+    tag: 'needs_reauth';
+    connectionId: MailchimpConnectionId;
+}>;
+export type ServerResolvedMailchimpConnectionState = Readonly<{
+    tag: 'not_connected';
+    [serverResolvedMailchimpConnectionStateBrand]: true;
+}> | Readonly<{
+    tag: 'connected';
+    connectionId: MailchimpConnectionId;
+    [serverResolvedMailchimpConnectionStateBrand]: true;
+}> | Readonly<{
+    tag: 'needs_reauth';
+    connectionId: MailchimpConnectionId;
+    [serverResolvedMailchimpConnectionStateBrand]: true;
+}>;
+export type MailchimpAudienceCompatibilityIssue = Readonly<{
+    tag: 'required_merge_field';
+    fieldTag: string;
+    fieldType: string | null;
+}> | Readonly<{
+    tag: 'unsupported_required_interest_group';
+    name: string | null;
+}> | Readonly<{
+    tag: 'unsupported_marketing_permissions';
+}> | Readonly<{
+    tag: 'unsupported_sms_field';
+}>;
+export type MailchimpMergeFieldCompatibilityInput = Readonly<{
+    fieldTag: string;
+    fieldType: string | null;
+    required: boolean;
+}>;
+export type MailchimpRequiredMergeField = Readonly<{
+    fieldTag: string;
+    fieldType: string | null;
+}>;
+export type MailchimpRequiredInterestGroup = Readonly<{
+    name: string | null;
+}>;
+export type NewsletterSignupFormCompatibilityFingerprint = Readonly<{
+    preset: NewsletterSignupFieldPreset;
+    includePhone: boolean;
+}>;
+export type MailchimpAudienceCompatibilityInput = Readonly<{
+    requiredMergeFields: readonly MailchimpRequiredMergeField[];
+    requiredInterestGroups?: readonly MailchimpRequiredInterestGroup[];
+    marketingPermissionsRequired?: boolean;
+    smsSignupRequired?: boolean;
+}>;
+export type MailchimpAudienceCompatibilityValidation = Readonly<{
+    tag: 'pending';
+}> | Readonly<{
+    tag: 'validated';
+    connectionId: MailchimpConnectionId;
+    audienceId: MailchimpAudienceId;
+    form: NewsletterSignupFormCompatibilityFingerprint;
+    issues: readonly MailchimpAudienceCompatibilityIssue[];
+}>;
+export type ServerValidatedMailchimpAudienceCompatibility = Extract<MailchimpAudienceCompatibilityValidation, {
+    tag: 'validated';
+}> & Readonly<{
+    [serverValidatedMailchimpAudienceCompatibilityBrand]: true;
+}>;
+export type NewsletterSignupDestinationReadinessIssue = Readonly<{
+    tag: 'invalid_destination_provider';
+    value: unknown;
+}> | Readonly<{
+    tag: 'riverbank_list_required';
+}> | Readonly<{
+    tag: 'mailchimp_connection_required';
+}> | Readonly<{
+    tag: 'mailchimp_connection_needs_reauth';
+}> | Readonly<{
+    tag: 'mailchimp_audience_required';
+}> | Readonly<{
+    tag: 'mailchimp_compatibility_validation_pending';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_tags';
+}> | Readonly<{
+    tag: 'mailchimp_audience_incompatible';
+    issues: readonly MailchimpAudienceCompatibilityIssue[];
+}>;
+export type NewsletterSignupDestinationReadiness = Readonly<{
+    tag: 'ready';
+}> | Readonly<{
+    tag: 'blocked';
+    issues: NonEmptyReadonlyArray<NewsletterSignupDestinationReadinessIssue>;
+}>;
+export type NewsletterSignupDestinationActivationIssue = Readonly<{
+    tag: 'invalid_destination_provider';
+    value: unknown;
+}> | Readonly<{
+    tag: 'invalid_mailchimp_destination';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_connection_id';
+}> | Readonly<{
+    tag: 'mailchimp_audience_required';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_audience_id';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_tags';
+}> | Readonly<{
+    tag: 'mailchimp_server_readiness_unavailable';
+}>;
+export type NewsletterSignupDestinationActivationInput = Readonly<{
+    tag: 'unresolved_authoring_content';
+    content: NewsletterSignupRawAuthoringContent;
+}>;
+export type NewsletterSignupDestinationActivationReadiness = Readonly<{
+    tag: 'ready';
+}> | Readonly<{
+    tag: 'blocked';
+    issues: NonEmptyReadonlyArray<NewsletterSignupDestinationActivationIssue>;
+}>;
+export type NewsletterSignupDestinationProviderOption = Readonly<{
+    tag: 'available';
+    value: 'riverbank';
+    label: string;
+}> | Readonly<{
+    tag: 'unavailable';
+    value: 'mailchimp';
+    label: string;
+    reason: 'connection_and_compatibility_pending';
+}>;
+export type NewsletterSignupDestinationParseError = Readonly<{
+    tag: 'missing_destination';
+}> | Readonly<{
+    tag: 'mixed_legacy_and_destination';
+}> | Readonly<{
+    tag: 'invalid_destination_shape';
+}> | Readonly<{
+    tag: 'invalid_destination_tag';
+    value: unknown;
+}> | Readonly<{
+    tag: 'invalid_destination_provider';
+    value: unknown;
+}> | Readonly<{
+    tag: 'conflicting_destination_provider';
+}> | Readonly<{
+    tag: 'invalid_newsletter_list_id';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_connection_id';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_audience_id';
+}> | Readonly<{
+    tag: 'invalid_mailchimp_tags';
+}>;
+export type NewsletterSignupDestinationParseResult = Readonly<{
+    success: true;
+    data: NewsletterSignupAuthoringState;
+}> | Readonly<{
+    success: false;
+    error: NewsletterSignupDestinationParseError;
+}>;
+export declare function parseNewsletterListId(value: unknown): NewsletterListId | null;
+export declare function parseMailchimpConnectionId(value: unknown): MailchimpConnectionId | null;
+export declare function parseMailchimpAudienceId(value: unknown): MailchimpAudienceId | null;
+export declare function parseMailchimpTagName(value: unknown): MailchimpTagName | null;
+export declare function parseNewsletterSignupBlockId(value: unknown): NewsletterSignupBlockId | null;
+export declare function parseSignedNewsletterDestinationRef(value: unknown): SignedNewsletterDestinationRef | null;
+export declare function parseNewsletterSignupDestinationProvider(value: unknown): NewsletterSignupDestinationProvider | null;
+export declare function parseNewsletterSignupAuthoringDestination(content: unknown): NewsletterSignupDestinationParseResult;
+export declare function normalizeNewsletterSignupAuthoringDestination(content: NewsletterSignupRawAuthoringContent): NewsletterSignupAuthoringDestination | null;
+export declare function assertValidNewsletterSignupAuthoringDestination(destination: NewsletterSignupAuthoringDestination): NewsletterSignupAuthoringDestination;
+export declare function buildNewsletterSignupBlockRef(blockId: string | null | undefined): NewsletterSignupPublicDestinationRef | null;
+export declare function selectNewsletterDestinationEditorFields(destination: NewsletterSignupAuthoringDestination | NewsletterSignupDestinationProvider | null, connectionState?: MailchimpConnectionEditorState): NewsletterSignupDestinationEditorFieldState;
+export declare function normalizeNewsletterSignupEditorValuesForDestination(values: NewsletterSignupEditorValues): NormalizedNewsletterSignupEditorValues;
+export declare function buildTrustedNewsletterSignupAuthoringDestination(input: Readonly<{
+    values: NewsletterSignupEditorValues;
+    connectionState?: ServerResolvedMailchimpConnectionState;
+    form?: NewsletterSignupFormCompatibilityFingerprint;
+    compatibility?: ServerValidatedMailchimpAudienceCompatibility;
+}>): TrustedNewsletterSignupAuthoringDestinationResult;
+export declare function deriveNewsletterSignupRuntimeSource(values: NewsletterSignupEditorValues): NewsletterSignupRuntimeSource;
+export declare function unsafeAssumeServerResolvedMailchimpConnectionState(state: MailchimpConnectionEditorState): ServerResolvedMailchimpConnectionState;
+export declare function unsafeAssumeServerValidatedMailchimpAudienceCompatibility(validation: Extract<MailchimpAudienceCompatibilityValidation, {
+    tag: 'validated';
+}>): ServerValidatedMailchimpAudienceCompatibility;
+export declare function sanitizeNewsletterSignupPublicContent(content: unknown): unknown;
+export declare function validateNewsletterSignupDestinationReadiness(input: Readonly<{
+    values: NewsletterSignupEditorValues;
+    connectionState?: MailchimpConnectionEditorState;
+    form?: NewsletterSignupFormCompatibilityFingerprint;
+    compatibility?: MailchimpAudienceCompatibilityValidation;
+}>): NewsletterSignupDestinationReadiness;
+export declare function validateNewsletterSignupDestinationActivationReadiness(input: NewsletterSignupDestinationActivationInput): NewsletterSignupDestinationActivationReadiness;
+export declare function selectRequiredMailchimpMergeFields(fields: readonly MailchimpMergeFieldCompatibilityInput[]): readonly MailchimpRequiredMergeField[];
+export declare function deriveMailchimpAudienceCompatibilityIssues(input: MailchimpAudienceCompatibilityInput): readonly MailchimpAudienceCompatibilityIssue[];
+export declare function selectNewsletterSignupDestinationProviderOptions(): readonly NewsletterSignupDestinationProviderOption[];
+export declare function getNewsletterSignupDestinationProvider(content: NewsletterSignupRawAuthoringContent): NewsletterSignupDestinationProvider;
+export {};

package/dist/_dts/blocks/src/system/blocks/newsletter-signup.d.ts

@@ -1,6 +1,7 @@
 import type { SystemBlockDefinition } from "../registry";
 import type { SectionStylesContent } from "../fields/boxStyles";
 import { newsletterFormBlockRuntime } from "../runtime/nodes/newsletter-form.interactive";
+import type { NewsletterSignupAuthoringDestination, NewsletterSignupFieldPreset } from "./newsletter-signup-destination";
 export declare const newsletterSignupManifest: import("..").DefinedBlockManifest<import("..").BlockContentShapeInput<{
     readonly id: "block.newsletter-signup";
     readonly title: "Newsletter Signup";
@@ -25,15 +26,60 @@ export declare const newsletterSignupManifest: import("..").DefinedBlockManifest
     }, {
         readonly fragment: import("..").DefinedFragment<{
             readonly fields: readonly [{
+                readonly id: "destinationProvider";
+                readonly type: "select";
+                readonly label: "Send signups to";
+                readonly description: "Choose where new subscribers from this form should go.";
+                readonly defaultValue: "riverbank";
+                readonly required: true;
+                readonly ui: {
+                    readonly intent: "behavior";
+                };
+                readonly options: [{
+                    readonly value: "riverbank";
+                    readonly label: "Riverbank newsletter";
+                }];
+            }, {
                 readonly id: "listId";
                 readonly type: "reference";
                 readonly label: "Newsletter list";
                 readonly description: "Select the list new subscribers should be added to.";
-                readonly required: true;
+                readonly required: false;
                 readonly referenceKind: "newsletterList";
                 readonly allowManualEntry: false;
                 readonly ui: {
                     readonly intent: "behavior";
+                    readonly visibleWhen: {
+                        readonly field: "destinationProvider";
+                        readonly equals: "riverbank";
+                    };
+                };
+            }, {
+                readonly id: "mailchimpAudienceId";
+                readonly type: "reference";
+                readonly label: "Mailchimp audience";
+                readonly description: "Choose the Mailchimp audience for new subscribers.";
+                readonly required: false;
+                readonly referenceKind: "mailchimpAudience";
+                readonly allowManualEntry: false;
+                readonly ui: {
+                    readonly intent: "behavior";
+                    readonly visibleWhen: {
+                        readonly field: "destinationProvider";
+                        readonly equals: "mailchimp";
+                    };
+                };
+            }, {
+                readonly id: "mailchimpTags";
+                readonly type: "text";
+                readonly label: "Mailchimp tags";
+                readonly description: "Optional tags to apply in Mailchimp, separated by commas or semicolons.";
+                readonly ui: {
+                    readonly intent: "behavior";
+                    readonly visibleWhen: {
+                        readonly field: "destinationProvider";
+                        readonly equals: "mailchimp";
+                    };
                 };
             }, {
                 readonly id: "preset";
@@ -87,6 +133,13 @@ export declare const newsletterSignupManifest: import("..").DefinedBlockManifest
                 readonly type: "text";
                 readonly label: "Tags (optional)";
                 readonly description: "Optional tags to apply on subscribe (comma or semicolon separated).";
+                readonly ui: {
+                    readonly intent: "behavior";
+                    readonly visibleWhen: {
+                        readonly field: "destinationProvider";
+                        readonly equals: "riverbank";
+                    };
+                };
             }];
         }>;
         readonly fieldPriority: 1;
@@ -136,15 +189,22 @@ type NewsletterRichTextDoc = {
         [key: string]: unknown;
     }>;
 };
-export type NewsletterSignupPreset = 'emailOnly' | 'emailName' | 'emailFirstLast' | 'emailNameCompany';
+export type NewsletterSignupPreset = NewsletterSignupFieldPreset;
 export type NewsletterSignupContent = {
     title?: string | null;
     subtitle?: NewsletterRichTextDoc | null;
+    listId?: string | null;
     preset: NewsletterSignupPreset;
+    includePhone?: boolean | null;
     buttonLabel?: string | null;
     successMessage?: string | null;
     privacyNote?: string | null;
+    tags?: string | null;
     _sectionStyles?: SectionStylesContent;
 };
+export type NewsletterSignupAuthoringContent = Omit<NewsletterSignupContent, 'listId' | 'tags'> & {
+    destination: NewsletterSignupAuthoringDestination;
+};
+export { buildTrustedNewsletterSignupAuthoringDestination, sanitizeNewsletterSignupPublicContent, validateNewsletterSignupDestinationActivationReadiness, } from "./newsletter-signup-destination";
+export type { MailchimpAudienceCompatibilityIssue, MailchimpAudienceId, MailchimpConnectionId, MailchimpNewsletterDestination, MailchimpTagName, NewsletterListId, NewsletterSignupAuthoringDestination, NewsletterSignupDestinationActivationIssue, NewsletterSignupDestinationActivationInput, NewsletterSignupDestinationActivationReadiness, NewsletterSignupBlockId, NewsletterSignupDestinationEditorFieldState, NewsletterSignupDestinationReadinessIssue, NewsletterSignupFieldPreset, NewsletterSignupDestinationProviderOption, NewsletterSignupPublicDestinationRef, RiverbankNewsletterDestination, ServerResolvedMailchimpConnectionState, ServerValidatedMailchimpAudienceCompatibility, SignedNewsletterDestinationRef, TrustedNewsletterSignupAuthoringDestinationError, TrustedNewsletterSignupAuthoringDestinationResult, } from "./newsletter-signup-destination";
 export declare const newsletterSignupBlockDefinition: SystemBlockDefinition<NewsletterSignupContent, typeof newsletterFormBlockRuntime>;
-export {};