@useinsider/guido 1.3.1-beta.7276301 → 1.3.1-beta.cf510dd

package/dist/src/@types/config/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Guido Configuration Types
+ *
+ * TypeScript types inferred from Valibot schemas.
+ * This ensures type definitions are always in sync with validation.
+ * @module @types/config/types
+ */
+import type { GuidoConfigSchema, IdentitySchema, PartnerSchema, TemplateSchema, EditorSchema, UISchema, FeaturesSchema, BlocksSchema, CompilerSchema, DynamicContentSchema, EmailHeaderSchema, CompilerRuleSchema, ReplaceRuleSchema, RegexRuleSchema, RemoveRuleSchema, CustomRuleSchema, DefaultBlockTypeSchema, CustomBlockTypeSchema } from './schemas';
+import type * as v from 'valibot';
+/**
+ * Complete validated Guido configuration.
+ *
+ * This is the type returned by `parseConfig()` after validation and default application.
+ * All optional fields have their defaults applied.
+ * @example
+ * ```typescript
+ * const config: GuidoConfig = parseConfig({
+ *   identity: { templateId: 'tpl-1', userId: 'usr-1' },
+ *   partner: { name: 'acme-corp' },
+ * });
+ *
+ * // Access validated config
+ * config.features.dynamicContent; // true (default)
+ * config.ui.showHeader; // true (default)
+ * ```
+ */
+export type GuidoConfig = v.InferOutput<typeof GuidoConfigSchema>;
+/** Identity configuration (templateId, userId, variationId) */
+export type IdentityConfig = v.InferOutput<typeof IdentitySchema>;
+/** Partner configuration (name, productType, messageType, username) */
+export type PartnerConfig = v.InferOutput<typeof PartnerSchema>;
+/** Template configuration (html, css, dynamic content, unsubscribe pages) */
+export type TemplateConfig = v.InferOutput<typeof TemplateSchema>;
+/** Editor configuration (locale, translations, migration date, email header) */
+export type EditorConfig = v.InferOutput<typeof EditorSchema>;
+/** UI configuration (showHeader, backButtonLabel) */
+export type UIConfig = v.InferOutput<typeof UISchema>;
+/** Features configuration (feature toggles) */
+export type FeaturesConfig = v.InferOutput<typeof FeaturesSchema>;
+/** Blocks configuration (exclude defaults, include customs) */
+export type BlocksConfig = v.InferOutput<typeof BlocksSchema>;
+/** Compiler configuration (custom rules, ignore defaults) */
+export type CompilerConfig = v.InferOutput<typeof CompilerSchema>;
+/** Email header configuration (senderName, subject) */
+export type EmailHeader = v.InferOutput<typeof EmailHeaderSchema>;
+/** Dynamic content item */
+export type DynamicContent = v.InferOutput<typeof DynamicContentSchema>;
+/**
+ * Input type for Guido configuration (allows partials).
+ *
+ * This is the type you use when passing config to the `<Guido>` component.
+ * Optional sections can be omitted - defaults will be applied during validation.
+ * @example
+ * ```typescript
+ * // Minimal config (only required fields)
+ * const minimalConfig: GuidoConfigInput = {
+ *   identity: { templateId: 'tpl-1', userId: 'usr-1' },
+ *   partner: { name: 'acme-corp' },
+ * };
+ *
+ * // Full config with overrides
+ * const fullConfig: GuidoConfigInput = {
+ *   identity: { templateId: 'tpl-1', userId: 'usr-1', variationId: 'v-a' },
+ *   partner: { name: 'acme-corp', productType: 60, messageType: 1 },
+ *   template: { html: '<p>Hello</p>', css: '' },
+ *   features: { dynamicContent: true, versionHistory: false },
+ *   blocks: { includeCustoms: ['recommendation-block'] },
+ * };
+ * ```
+ */
+export type GuidoConfigInput = v.InferInput<typeof GuidoConfigSchema>;
+/** Input type for identity configuration */
+export type IdentityConfigInput = v.InferInput<typeof IdentitySchema>;
+/** Input type for partner configuration */
+export type PartnerConfigInput = v.InferInput<typeof PartnerSchema>;
+/** Input type for template configuration */
+export type TemplateConfigInput = v.InferInput<typeof TemplateSchema>;
+/** Input type for editor configuration */
+export type EditorConfigInput = v.InferInput<typeof EditorSchema>;
+/** Input type for UI configuration */
+export type UIConfigInput = v.InferInput<typeof UISchema>;
+/** Input type for features configuration */
+export type FeaturesConfigInput = v.InferInput<typeof FeaturesSchema>;
+/** Input type for blocks configuration */
+export type BlocksConfigInput = v.InferInput<typeof BlocksSchema>;
+/** Input type for compiler configuration */
+export type CompilerConfigInput = v.InferInput<typeof CompilerSchema>;
+/** Default Stripo block types */
+export type DefaultBlockType = v.InferOutput<typeof DefaultBlockTypeSchema>;
+/** Custom Guido block types */
+export type CustomBlockType = v.InferOutput<typeof CustomBlockTypeSchema>;
+/** All available block types */
+export type BlockType = DefaultBlockType | CustomBlockType;
+/**
+ * Union type for all compiler rules.
+ * @example
+ * ```typescript
+ * const rules: CompilerRule[] = [
+ *   // Replace rule - simple string replacement
+ *   {
+ *     id: 'replace-domain',
+ *     type: 'replace',
+ *     search: 'old-domain.com',
+ *     replacement: 'new-domain.com',
+ *     priority: 10,
+ *   },
+ *   // Regex rule - pattern matching
+ *   {
+ *     id: 'remove-comments',
+ *     type: 'regex',
+ *     pattern: '<!--.*?-->',
+ *     replacement: '',
+ *     flags: 'gs',
+ *     priority: 20,
+ *   },
+ *   // Custom rule - processor function
+ *   {
+ *     id: 'add-tracking',
+ *     type: 'custom',
+ *     processor: (html) => html.replace('</body>', '<img src="track.gif"/></body>'),
+ *     priority: 30,
+ *   },
+ * ];
+ * ```
+ */
+export type CompilerRule = v.InferOutput<typeof CompilerRuleSchema>;
+/** Replace rule - simple string replacement */
+export type ReplaceRule = v.InferOutput<typeof ReplaceRuleSchema>;
+/** Regex rule - regular expression pattern matching */
+export type RegexRule = v.InferOutput<typeof RegexRuleSchema>;
+/** Remove rule - remove matching content */
+export type RemoveRule = v.InferOutput<typeof RemoveRuleSchema>;
+/** Custom rule - custom processor function */
+export type CustomRule = v.InferOutput<typeof CustomRuleSchema>;
+/** Deep partial type for config sections */
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/** Config override type for presets */
+export type ConfigOverrides = DeepPartial<Omit<GuidoConfig, 'identity' | 'partner'>>;
+/** Feature name type */
+export type FeatureName = keyof FeaturesConfig;

package/dist/src/@types/config/validator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Guido Configuration Validator
+ *
+ * Utilities for validating and parsing Guido configuration.
+ * Provides both throwing and non-throwing validation methods.
+ * @module @types/config/validator
+ */
+import type { GuidoConfig, GuidoConfigInput } from './types';
+/**
+ * Result of config validation
+ */
+export interface ValidationResult {
+    /** Whether validation was successful */
+    success: boolean;
+    /** Validated and transformed config (only if success) */
+    data?: GuidoConfig;
+    /** Validation error messages (only if failed) */
+    errors?: string[];
+}
+/**
+ * Formatted validation error with path and message
+ */
+export interface ValidationError {
+    /** Dot-notation path to the invalid field */
+    path: string;
+    /** Error message */
+    message: string;
+}
+/**
+ * Validates configuration input and returns a result object.
+ *
+ * Use this for non-throwing validation where you want to handle errors yourself.
+ * @example
+ * ```typescript
+ * const result = validateConfig({
+ *   identity: { templateId: 'tpl-1', userId: 'usr-1' },
+ *   partner: { name: 'acme-corp' },
+ * });
+ *
+ * if (result.success) {
+ *   console.log(result.data); // Full GuidoConfig with defaults
+ * } else {
+ *   console.error(result.errors); // ['[identity.templateId] templateId is required']
+ * }
+ * ```
+ * @param input - Raw configuration input
+ * @returns Validation result with success status and data or errors
+ */
+export declare function validateConfig(input: GuidoConfigInput): ValidationResult;
+/**
+ * Validates configuration and throws on error.
+ *
+ * Use this during component initialization where invalid config should halt execution.
+ * @example
+ * ```typescript
+ * try {
+ *   const config = parseConfig({
+ *     identity: { templateId: 'tpl-1', userId: 'usr-1' },
+ *     partner: { name: 'acme-corp' },
+ *   });
+ *   // config is fully typed GuidoConfig
+ * } catch (error) {
+ *   console.error('Invalid configuration:', error.message);
+ * }
+ * ```
+ * @param input - Raw configuration input
+ * @returns Validated GuidoConfig with all defaults applied
+ */
+export declare function parseConfig(input: GuidoConfigInput): GuidoConfig;
+/**
+ * Validates configuration with console warnings (non-throwing).
+ *
+ * Use this when you want to attempt recovery from invalid config.
+ * Returns null on failure instead of throwing.
+ * @example
+ * ```typescript
+ * const config = parseConfigSafe(userInput);
+ * if (!config) {
+ *   // Use fallback configuration
+ *   return defaultConfig;
+ * }
+ * ```
+ * @param input - Raw configuration input
+ * @returns Validated GuidoConfig or null if validation fails
+ */
+export declare function parseConfigSafe(input: GuidoConfigInput): GuidoConfig | null;
+/**
+ * Get structured validation errors for detailed error handling.
+ * @example
+ * ```typescript
+ * const errors = getValidationErrors(input);
+ * errors.forEach(({ path, message }) => {
+ *   formErrors[path] = message;
+ * });
+ * ```
+ * @param input - Raw configuration input
+ * @returns Array of validation errors with paths, or empty array if valid
+ */
+export declare function getValidationErrors(input: GuidoConfigInput): ValidationError[];
+/**
+ * Check if a configuration input is valid without parsing.
+ * @example
+ * ```typescript
+ * if (isValidConfig(userInput)) {
+ *   saveConfig(userInput);
+ * }
+ * ```
+ * @param input - Raw configuration input
+ * @returns True if valid, false otherwise
+ */
+export declare function isValidConfig(input: unknown): input is GuidoConfigInput;
+/**
+ * Validate just the identity section
+ */
+export declare function validateIdentity(input: unknown): ValidationResult;
+/**
+ * Validate just the partner section
+ */
+export declare function validatePartner(input: unknown): ValidationResult;

package/dist/src/@types/generic.d.ts

@@ -1,43 +1,7 @@
-import type { CompilerRule } from './html-compiler';
-type Extensions = {
-    unsubscribe?: boolean;
-};
-type Features = {
-    dynamicContent?: boolean;
-    saveAsTemplate?: boolean;
-    versionHistory?: boolean;
-    testMessage?: boolean;
-    displayConditions?: boolean;
-};
-type Partner = {
-    partnerName: string;
-    productType: number;
-    messageType: number;
-};
-export type GuidoBlockType = 'amp-accordion' | 'amp-carousel' | 'amp-form-controls' | 'banner-block' | 'button-block' | 'html-block' | 'image-block' | 'menu-block' | 'social-block' | 'spacer-block' | 'text-block' | 'timer-block' | 'video-block';
-export type GuidoCustomBlockType = 'dynamic-content' | 'checkbox-block' | 'radio-button-block' | 'recommendation-block' | 'unsubscribe-block' | 'coupon-block' | 'items-block';
-type BlocksConfig = {
-    excludeDefaults?: GuidoBlockType[];
-    includeCustoms?: GuidoCustomBlockType[];
-};
-export type GuidoConfig = {
-    translationsPath: string;
-    htmlCompilerRules?: CompilerRule[];
-    ignoreDefaultHtmlCompilerRules?: boolean;
-    useHeader?: boolean;
-    emailHeader: EmailHeader;
-    migrationDate: number;
-    partner?: Partner;
-    extensions?: Extensions;
-    features?: Features;
-    blocks?: BlocksConfig;
-    backButtonLabel?: string;
-};
-export type TemplateConfig = {
-    preselectedDynamicContentList?: DynamicContent[];
-    selectedUnsubscribePages?: number[];
-    variationId?: string;
-};
+/**
+ * Generic types used throughout the application.
+ * Note: Configuration types are now in @types/config/
+ */
 export type BaseDynamicContent = {
     value: string;
     fallback?: string;
@@ -71,10 +35,6 @@ export type MergeTagClickEvent = {
     tagValue: string | null;
     tagLabel: string | null;
 };
-export interface EmailHeader {
-    senderName: string;
-    subject: string;
-}
 export interface TooltipOptions {
     id: string;
     dynamicPosition: boolean;
@@ -95,4 +55,3 @@ export interface L10n {
     timezone?: string;
     time?: number;
 }
-export {};

package/dist/src/components/Guido.vue.d.ts

@@ -1,16 +1,9 @@
-import type { DynamicContent, GuidoConfig, PositionData, TemplateConfig } from '@@/Types/generic';
+import type { DynamicContent, GuidoConfigInput } from '@@/Types/config';
+import type { PositionData } from '@@/Types/generic';
 import type { SavedTemplateDetails } from '@@/Types/stripo';
 type __VLS_Props = {
-    templateId: string;
-    userId: string;
-    messageType?: number;
-    partnerName?: string;
-    productType?: number;
-    username?: string;
-    html?: string;
-    css?: string;
-    guidoConfig: GuidoConfig;
-    templateConfig?: TemplateConfig;
+    /** Guido configuration object */
+    config: GuidoConfigInput;
 };
 declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {
     dynamicContent: {
@@ -20,7 +13,15 @@ declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__
     hasChanges: import("vue").ComputedRef<boolean>;
     saveSilent: () => Promise<SavedTemplateDetails | undefined> | undefined;
 }, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {
-    "dynamic-content:open": (detail: DynamicContent | null, position?: PositionData | undefined) => void;
+    "dynamic-content:open": (detail: {
+        text: string;
+        value: string;
+        fallback?: string | undefined;
+        format?: {
+            key: string;
+            value: string;
+        } | undefined;
+    } | null, position?: PositionData | undefined) => void;
     back: () => void;
     "save:start": () => void;
     "save:complete": (data: Omit<SavedTemplateDetails, "forceRecreate">) => void;

package/dist/src/components/wrappers/WpModal.vue.d.ts

@@ -32,8 +32,8 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<
     closeOnOutsideClick: boolean;
     footerStatus: boolean;
 }>>>, {
-    size: "small" | "medium" | "large";
     description: string;
+    size: "small" | "medium" | "large";
     closeOnOutsideClick: boolean;
     footerButtonOptions: FooterButtonGroup;
     closeButtonStatus: boolean;

package/dist/src/composables/useConfig.d.ts

@@ -1,4 +1,186 @@
-import type { GuidoConfig } from '@@/Types/generic';
+import type { GuidoConfig, FeaturesConfig } from '@@/Types/config';
+/**
+ * Composable for accessing Guido configuration
+ *
+ * Provides access to the validated configuration from the config store.
+ * All values are reactive and will update when the config changes.
+ */
 export declare const useConfig: () => {
-    config: GuidoConfig;
+    config: import("vue").Ref<{
+        identity: {
+            templateId: string;
+            userId: string;
+            variationId?: string | undefined;
+        };
+        partner: {
+            name: string;
+            productType: 60 | 49 | 97;
+            messageType: 1 | 2;
+            username: string;
+        };
+        template: {
+            html: string;
+            css: string;
+            preselectedDynamicContent: {
+                text: string;
+                value: string;
+                fallback?: string | undefined;
+                format?: {
+                    key: string;
+                    value: string;
+                } | undefined;
+            }[];
+            selectedUnsubscribePages: number[];
+        };
+        editor: {
+            locale: string;
+            translationsPath: string;
+            migrationDate: number;
+            emailHeader: {
+                senderName: string;
+                subject: string;
+            };
+        };
+        ui: {
+            showHeader: boolean;
+            backButtonLabel?: string | undefined;
+        };
+        features: {
+            dynamicContent: boolean;
+            saveAsTemplate: boolean;
+            versionHistory: boolean;
+            testMessage: boolean;
+            displayConditions: boolean;
+            unsubscribe: boolean;
+        };
+        blocks: {
+            excludeDefaults: ("amp-accordion" | "amp-carousel" | "amp-form-controls" | "banner-block" | "button-block" | "html-block" | "image-block" | "menu-block" | "social-block" | "spacer-block" | "text-block" | "timer-block" | "video-block")[];
+            includeCustoms: ("dynamic-content" | "checkbox-block" | "radio-button-block" | "recommendation-block" | "unsubscribe-block" | "coupon-block" | "items-block")[];
+        };
+        compiler: {
+            customRules: ({
+                type: "replace";
+                search: string;
+                replacement: string;
+                replaceAll?: boolean | undefined;
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            } | {
+                type: "regex";
+                pattern: string;
+                replacement: string;
+                flags?: string | undefined;
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            } | {
+                type: "remove";
+                targets: string[];
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            } | {
+                type: "custom";
+                processor: (html: string) => string;
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            })[];
+            ignoreDefaultRules: boolean;
+        };
+    } | null>;
+    initialized: import("vue").Ref<boolean>;
+    identity: import("vue").ComputedRef<{
+        templateId: string;
+        userId: string;
+        variationId?: string | undefined;
+    } | null>;
+    partner: import("vue").ComputedRef<{
+        name: string;
+        productType: 60 | 49 | 97;
+        messageType: 1 | 2;
+        username: string;
+    } | null>;
+    template: import("vue").ComputedRef<{
+        html: string;
+        css: string;
+        preselectedDynamicContent: {
+            text: string;
+            value: string;
+            fallback?: string | undefined;
+            format?: {
+                key: string;
+                value: string;
+            } | undefined;
+        }[];
+        selectedUnsubscribePages: number[];
+    } | null>;
+    editor: import("vue").ComputedRef<{
+        locale: string;
+        translationsPath: string;
+        migrationDate: number;
+        emailHeader: {
+            senderName: string;
+            subject: string;
+        };
+    } | null>;
+    ui: import("vue").ComputedRef<{
+        showHeader: boolean;
+        backButtonLabel?: string | undefined;
+    } | null>;
+    features: import("vue").ComputedRef<{
+        dynamicContent: boolean;
+        saveAsTemplate: boolean;
+        versionHistory: boolean;
+        testMessage: boolean;
+        displayConditions: boolean;
+        unsubscribe: boolean;
+    } | null>;
+    blocks: import("vue").ComputedRef<{
+        excludeDefaults: ("amp-accordion" | "amp-carousel" | "amp-form-controls" | "banner-block" | "button-block" | "html-block" | "image-block" | "menu-block" | "social-block" | "spacer-block" | "text-block" | "timer-block" | "video-block")[];
+        includeCustoms: ("dynamic-content" | "checkbox-block" | "radio-button-block" | "recommendation-block" | "unsubscribe-block" | "coupon-block" | "items-block")[];
+    } | null>;
+    compiler: import("vue").ComputedRef<{
+        customRules: ({
+            type: "replace";
+            search: string;
+            replacement: string;
+            replaceAll?: boolean | undefined;
+            id: string;
+            description?: string | undefined;
+            priority: number;
+        } | {
+            type: "regex";
+            pattern: string;
+            replacement: string;
+            flags?: string | undefined;
+            id: string;
+            description?: string | undefined;
+            priority: number;
+        } | {
+            type: "remove";
+            targets: string[];
+            id: string;
+            description?: string | undefined;
+            priority: number;
+        } | {
+            type: "custom";
+            processor: (html: string) => string;
+            id: string;
+            description?: string | undefined;
+            priority: number;
+        })[];
+        ignoreDefaultRules: boolean;
+    } | null>;
+    templateId: import("vue").ComputedRef<string>;
+    userId: import("vue").ComputedRef<string>;
+    variationId: import("vue").ComputedRef<string>;
+    partnerName: import("vue").ComputedRef<string>;
+    productType: import("vue").ComputedRef<number>;
+    messageType: import("vue").ComputedRef<number>;
+    username: import("vue").ComputedRef<string>;
+    showHeader: import("vue").ComputedRef<boolean>;
+    getConfig: () => GuidoConfig | null;
+    isFeatureEnabled: (feature: keyof FeaturesConfig) => boolean;
 };

package/dist/src/composables/usePartner.d.ts

@@ -1,5 +1,13 @@
+/**
+ * Composable for accessing partner information
+ *
+ * Provides access to partner data from the config store,
+ * with fallbacks to URL-based detection for backward compatibility.
+ */
 export declare const usePartner: () => {
     getPartnerName: () => string;
     getProductType: () => number;
+    getMessageType: () => number;
+    getUsername: () => string;
     isTestPartner: () => boolean;
 };

package/dist/src/enums/defaults.d.ts

@@ -1,12 +1,10 @@
-import type { GuidoConfig } from '@@/Types/generic';
-export declare const DefaultGuidoConfig: GuidoConfig;
+/**
+ * Default values and constants.
+ * Note: Configuration defaults are now in @types/config/defaults.ts
+ */
 export declare const TemplateTypes: {
     promotional: number;
     transactional: number;
 };
-export declare const DefaultProductType = "email";
-export declare const DefaultUsername = "Guido User";
-export declare const DefaultMessageType: number;
 export declare const EditorType: number;
 export declare const ProductIds: Record<string, number>;
-export declare const TEST_PARTNER_LIST: string[];

package/dist/src/enums/unsubscribe.d.ts

@@ -29,7 +29,11 @@ export declare const PAGE_TYPES: {
 export declare const TYPE_COLLECTIONS: {
     [x: number]: number[];
 };
-export declare const TYPE_TRANSLATIONS: {
+/**
+ * Get type translations lazily to avoid Pinia initialization issues.
+ * Must be called within a Vue component context or after Pinia is initialized.
+ */
+export declare const getTypeTranslations: () => {
     [x: number]: string;
 };
 export declare const MERGE_TAGS: {

package/dist/src/library.d.ts

@@ -1,3 +1,5 @@
 export { default as Guido } from './components/Guido.vue';
+export type { GuidoConfig, GuidoConfigInput, IdentityConfig, PartnerConfig, TemplateConfig, EditorConfig, UIConfig, FeaturesConfig, BlocksConfig, CompilerConfig, DynamicContent, EmailHeader, DefaultBlockType, CustomBlockType, ValidationResult, ValidationError, } from './@types/config';
+export { validateConfig, parseConfig, parseConfigSafe, isValidConfig, getValidationErrors, MessageType, ProductType, } from './@types/config';
 export type { StripoEventType } from './@types/events';
-export type * from './@types/generic';
+export type { PositionData, DynamicContentEvent, MergeTagClickEvent, MergeTag, BaseDynamicContent, TooltipOptions, TextValueObject, L10n, } from './@types/generic';