@beworke/pixel-bemony 0.1.0-rc.1

package/dist/createBemonyPixel-BGRD66p-.d.mts

@@ -0,0 +1,474 @@
+import { PixelConfig, PixelDebugSnapshot } from '@beworke/pixel';
+import { ViewContentData, AddToCartData, RemoveFromCartData, LeadData, InitiateCheckoutData, AddPaymentInfoData } from '@beworke/pixel/events';
+
+/**
+ * Contexto público da página — pode ir para identity/navigation.
+ * Nunca inclui segredos (token one-click, cartão, etc.).
+ */
+interface BemonyPublicPageContext {
+    pageId?: string;
+    funnelId?: string;
+    funnelStepId?: string;
+    offerId?: string;
+    productId?: string;
+    /** Código público do price (`pri*`). Identidade comercial canônica. */
+    priceCode?: string;
+    /**
+     * @deprecated Use priceCode.
+     */
+    priceId?: string;
+    checkoutId?: string;
+    affiliateId?: string;
+    /** Correlação app/backend; sem campo dedicado no Core identity. */
+    publicOrderId?: string;
+}
+/**
+ * Input completo de contexto público da página.
+ */
+interface BemonyPageContextInput {
+    public: BemonyPublicPageContext;
+}
+/**
+ * Commerce mínimo para a factory de config (sem checkout completo).
+ * Opcional — Bemony não exige catálogo para emitir eventos com priceCode.
+ */
+interface BemonyCommerceInput {
+    currency?: string;
+    cartMode?: 'landing_page' | 'single_product' | 'checkout' | 'upsell' | 'custom';
+    products?: ReadonlyArray<{
+        id: string;
+        name?: string;
+        type?: string;
+        price?: number;
+        currency?: string;
+        quantity?: number;
+    }>;
+}
+type BemonyValidationErrorCode = 'MISSING_REQUIRED_FIELD' | 'MISSING_ENDPOINT' | 'INVALID_FIELD' | 'INVALID_ENVIRONMENT';
+type BemonyValidationErrorOptions = {
+    code: BemonyValidationErrorCode;
+    message: string;
+    field?: string;
+    scenario?: string;
+};
+/**
+ * Erro tipado de validação. Mensagens nunca devem incluir valores sensíveis.
+ */
+declare class BemonyValidationError extends Error {
+    readonly code: BemonyValidationErrorCode;
+    readonly field?: string;
+    readonly scenario?: string;
+    constructor(options: BemonyValidationErrorOptions);
+}
+declare function isBemonyPageContextInput(value: unknown): value is BemonyPageContextInput;
+declare function normalizeBemonyPageContextInput(page?: BemonyPageContextInput | BemonyPublicPageContext): BemonyPageContextInput;
+
+/**
+ * Defaults estáveis da plataforma Bemony (sem dados dinâmicos de página).
+ * Composição: DEFAULT_PIXEL_CONFIG → estes defaults → environment → scenario → page.
+ */
+declare const BEMONY_STORAGE_PREFIX = "__bemony_pixel";
+declare const BEMONY_DEFAULT_NAMESPACE: "bemony-web";
+/**
+ * Endpoint público padrão da API Pixel Bemony (infraestrutura, não credencial).
+ * O Core acrescenta `/pixels/public/event` e `/pixels/public/event/batch`.
+ */
+declare const BEMONY_DEFAULT_API_ENDPOINT: "https://micro-service-pixel-production-4826.up.railway.app";
+declare const BEMONY_DEFAULT_PIXEL_ID: "pix_7704308";
+/** Domínios Bemony permitidos por default para decoração de links. */
+declare const BEMONY_DEFAULT_ALLOWED_DOMAINS: readonly ["security.bemony.com", "localhost", "127.0.0.1", "local"];
+/** Ambiente padrão do auto-init do bundle global IIFE (não da factory programática). */
+declare const BEMONY_DEFAULT_BROWSER_ENVIRONMENT: "production";
+/** Cenário padrão do auto-init do bundle global IIFE. */
+declare const BEMONY_DEFAULT_BROWSER_SCENARIO: "offer-page";
+/**
+ * Defaults oficiais do auto-init browser (IIFE global).
+ * Imutável — merge deve clonar, nunca mutar.
+ */
+declare const BEMONY_BROWSER_AUTO_INIT_DEFAULTS: Readonly<{
+    environment: "production";
+    scenario: "offer-page";
+    platform: Readonly<{
+        pixelId: "pix_7704308";
+        apiEndpoint: "https://micro-service-pixel-production-4826.up.railway.app";
+        namespace: "bemony-web";
+        allowedDomains: readonly ("security.bemony.com" | "localhost" | "127.0.0.1" | "local")[];
+    }>;
+}>;
+type BemonyPlatformDefaults = {
+    app: {
+        source: 'bemony';
+    };
+    storage: {
+        prefix: typeof BEMONY_STORAGE_PREFIX;
+        namespace: typeof BEMONY_DEFAULT_NAMESPACE;
+        persistence: {
+            visitor: 'localStorage';
+            session: 'sessionStorage';
+            attribution: 'localStorage';
+        };
+    };
+    attribution: {
+        enabled: true;
+        persist: true;
+        captureUrlParams: true;
+        captureCookies: true;
+    };
+};
+declare const BEMONY_PLATFORM_DEFAULTS: BemonyPlatformDefaults;
+/**
+ * Opções de plataforma injetadas pelo app (sem hardcode de credenciais/endpoints).
+ */
+type BemonyPlatformOptions = {
+    /** Identidade obrigatória do pixel. */
+    pixelId: string;
+    /**
+     * Endpoint base da API Pixel.
+     * Obrigatório em staging/production; opcional em development (mock).
+     * Não inventar URL — injetar valor aprovado (env/provider).
+     */
+    apiEndpoint?: string;
+    /** Namespace estável por aplicação (não por página/oferta). */
+    namespace?: string;
+    /** Domínios aprovados para link decoration. */
+    allowedDomains?: readonly string[];
+    /** Override explícito de debug (senão segue o ambiente). */
+    debug?: boolean;
+};
+
+type BemonyEnvironment = 'development' | 'staging' | 'production';
+declare const BEMONY_ENVIRONMENTS: readonly BemonyEnvironment[];
+type BemonyEnvironmentResolution = {
+    environment: BemonyEnvironment;
+    debug: boolean;
+    /** Endpoint efetivo (pode ser '' em development com mock). */
+    apiEndpoint: string;
+    transportEnabled: boolean;
+    senderMode: 'mock' | 'http';
+};
+type ResolveBemonyEnvironmentOptions = {
+    environment: BemonyEnvironment;
+    apiEndpoint?: string;
+    debugOverride?: boolean;
+};
+/**
+ * Resolve comportamento por ambiente.
+ * Staging/production exigem endpoint injetado — nenhum URL inventado.
+ */
+declare function resolveBemonyEnvironment(options: ResolveBemonyEnvironmentOptions): BemonyEnvironmentResolution;
+
+/**
+ * Cenários de domínio Bemony (V1).
+ * Determinam comportamentos locais (eventos, detectores, params).
+ * Nenhum cenário consulta catálogo no bootstrap.
+ */
+type BemonyScenario = 'offer-page' | 'checkout' | 'upsell-offer' | 'one-click-checkout' | 'thank-you';
+declare const BEMONY_SCENARIOS: readonly BemonyScenario[];
+
+/**
+ * Overrides restritos e tipados (não expor Partial<PixelConfig>).
+ */
+type BemonyConfigOverrides = {
+    debug?: boolean;
+    apiEndpoint?: string;
+    allowedDomains?: readonly string[];
+};
+type CreateBemonyPixelConfigOptions = {
+    environment: BemonyEnvironment;
+    scenario: BemonyScenario;
+    platform: BemonyPlatformOptions;
+    page?: BemonyPageContextInput | BemonyPublicPageContext;
+    commerce?: BemonyCommerceInput;
+    /** Params públicos já filtrados da URL (sem token). */
+    urlParams?: Readonly<Record<string, string>>;
+    pageMetadata?: BemonyPublicPageContext;
+    scenarioDefaults?: BemonyPublicPageContext;
+    overrides?: BemonyConfigOverrides;
+    /**
+     * Quando false, desativa auto `startCheckout` no init (checkout).
+     * Default: true no cenário checkout.
+     */
+    autoInitiateCheckout?: boolean;
+    /**
+     * URL de “No Thanks” para upsell/downsell (`data-no-thanks` no script).
+     */
+    noThanksUrl?: string;
+};
+/**
+ * Compõe um PixelConfig válido para Bemony.
+ *
+ * Ordem: DEFAULT_PIXEL_CONFIG → platform → environment → scenario → page → overrides.
+ * Nunca inclui token efêmero. Não muta o input. Clona arrays.
+ */
+declare function createBemonyPixelConfig(options: CreateBemonyPixelConfigOptions): PixelConfig;
+
+/**
+ * Input opcional para `startCheckout` → `Pixel.initiateCheckout()`.
+ * Valor/itens podem ser enriquecidos pelo commerce do Core.
+ */
+interface BemonyCheckoutInput {
+    value?: number;
+    currency?: string;
+}
+
+/**
+ * Opções de `declineUpsell`.
+ *
+ * GAP explícito: o Core não possui evento público de recusa.
+ * Este método NÃO emite conversion falsa (não usa viewContent/addToCart/lead/etc.).
+ */
+type BemonyDeclineUpsellOptions = {
+    /** Callback do app (analytics próprio, UI, etc.). */
+    onDecline?: () => void;
+    /**
+     * URL da próxima etapa. Se definida, navega via `location.assign`.
+     * O backend/302 deve preservar `sid` / params públicos quando aplicável.
+     */
+    navigateTo?: string;
+};
+
+/**
+ * Normaliza a identidade comercial pública Bemony (`priceCode`).
+ *
+ * `priceId` permanece como alias deprecated de compatibilidade.
+ * Não inventa valor a partir de offerId/productId.
+ */
+type BemonyCommerceIdentityInput = {
+    priceCode?: string;
+    /** @deprecated Use priceCode. */
+    priceId?: string;
+};
+type ResolvePriceCodeResult = {
+    priceCode: string | null;
+    /** True quando priceCode e priceId divergem (usa priceCode). */
+    conflict: boolean;
+};
+/**
+ * Resolve o priceCode canônico.
+ *
+ * 1. `priceCode` tem prioridade
+ * 2. `priceId` é fallback de compatibilidade
+ * 3. trim; vazio → null
+ * 4. conflito → preferir priceCode e sinalizar `conflict`
+ */
+declare function resolvePriceCode(input: BemonyCommerceIdentityInput | null | undefined): ResolvePriceCodeResult;
+
+/**
+ * Input mínimo de oferta no browser.
+ *
+ * Identidade canônica: `priceCode`.
+ * Valor/moeda observados são opcionais e não são autoridade financeira.
+ * productId/offerId reais NÃO são inventados no browser.
+ */
+interface BemonyOfferInput extends BemonyCommerceIdentityInput {
+    quantity?: number;
+    /** Valor observado na UI (opcional; backend valida). */
+    observedValue?: number;
+    /** Moeda observada na UI (opcional; backend valida). */
+    observedCurrency?: string;
+    /**
+     * @deprecated Preferir observedValue. Mantido para hosts legados.
+     */
+    price?: number;
+    /**
+     * @deprecated Preferir observedCurrency.
+     */
+    currency?: string;
+    /**
+     * Tipo observado (upsell/downsell) — não resolve catálogo.
+     */
+    productType?: 'main' | 'order_bump' | 'upsell' | 'downsell' | 'cross_sell' | 'addon' | 'subscription' | 'custom' | 'other';
+}
+/**
+ * Oferta completa exige `priceCode` (ou `priceId` legado).
+ */
+declare function isCompleteBemonyOffer(input: BemonyOfferInput | null | undefined): input is BemonyOfferInput;
+
+/**
+ * Input de confirmação one-click (intenção no Pixel).
+ * Não processa pagamento e não emite PURCHASE.
+ * Identidade mínima: priceCode.
+ */
+type BemonyOneClickConfirmationInput = BemonyOfferInput;
+
+/**
+ * Input de lead para `captureLead` → `Pixel.lead()`.
+ * Não dispara ADD_TO_CART.
+ */
+interface BemonyLeadInput {
+    email?: string;
+    phone?: string;
+    name?: string;
+    fields?: Record<string, unknown>;
+}
+/**
+ * Validação mínima: email válido e/ou telefone com ao menos 8 dígitos.
+ */
+declare function isValidBemonyLead(input: BemonyLeadInput): boolean;
+declare function leadFingerprint(input: BemonyLeadInput): string;
+/**
+ * Remove campos sensíveis (cartão etc.) de `fields` antes de enviar ao Core.
+ */
+declare function sanitizeLeadFields(fields: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+
+/**
+ * Métodos de pagamento alinhados ao Core (`AddPaymentInfoData.paymentMethod`).
+ * `PaymentMethod` não é reexportado por `@beworke/pixel/events` — espelhamos o union.
+ */
+type BemonyPaymentMethod = 'CREDIT_CARD' | 'PIX' | 'BOLETO' | 'PAYPAL' | 'OTHER';
+/**
+ * Input de método de pagamento — somente enum, sem dados de cartão.
+ */
+interface BemonyPaymentMethodInput {
+    paymentMethod: BemonyPaymentMethod;
+}
+declare const BEMONY_PAYMENT_METHODS: readonly BemonyPaymentMethod[];
+declare function isValidBemonyPaymentMethod(input: BemonyPaymentMethodInput | null | undefined): input is BemonyPaymentMethodInput;
+
+type BemonyPixelState = 'created' | 'initializing' | 'ready' | 'destroying' | 'destroyed' | 'failed';
+/**
+ * Superfície pública do Core usada pelo wrapper.
+ * Não inclui métodos @internal nem purchase (fora do fluxo browser Bemony).
+ */
+type BemonyCorePixel = {
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isInitialized(): boolean;
+    getDebugSnapshot(): Readonly<PixelDebugSnapshot>;
+    viewContent(data?: ViewContentData): void;
+    addToCart(data?: AddToCartData): void;
+    removeFromCart(data?: RemoveFromCartData): void;
+    lead(data: LeadData): void;
+    initiateCheckout(data?: InitiateCheckoutData): void;
+    addPaymentInfo(data?: AddPaymentInfoData): void;
+    setManagedUrlParam?(param: string, value: string): boolean;
+};
+type BemonyPixelConstructOptions = {
+    config: PixelConfig;
+    scenario: BemonyScenario;
+    createCorePixel?: (config: PixelConfig) => BemonyCorePixel;
+    /** Default true no cenário checkout / one-click. */
+    autoInitiateCheckout?: boolean;
+    publicOrderId?: string;
+    publicContext?: BemonyPublicPageContext;
+    /**
+     * URL de “No Thanks” (`data-no-thanks` no script).
+     * O link de recusa é o `<a href>` que coincide com esta URL.
+     */
+    noThanksUrl?: string;
+};
+type BemonyLifecycleErrorCode = 'INIT_FAILED' | 'INVALID_STATE' | 'DESTROY_FAILED';
+declare class BemonyLifecycleError extends Error {
+    readonly code: BemonyLifecycleErrorCode;
+    readonly state: BemonyPixelState;
+    readonly cause?: unknown;
+    constructor(options: {
+        code: BemonyLifecycleErrorCode;
+        message: string;
+        state: BemonyPixelState;
+        cause?: unknown;
+    });
+}
+/**
+ * Identidade comercial do CTA de aceite: pathname do href (`/pri*`).
+ * Útil para hosts que resolvem o CTA manualmente; o cenário upsell usa LinkAuto.
+ */
+declare function resolvePriceCodeFromAcceptElement(el: Element): string | null;
+/**
+ * Wrapper de lifecycle e domínio Bemony sobre `Pixel`.
+ *
+ * Sem consulta de catálogo. Sem auto VIEW_CONTENT.
+ * Identidade comercial no browser: priceCode observado.
+ */
+declare class BemonyPixel {
+    private state;
+    private readonly scenario;
+    private readonly config;
+    private readonly core;
+    private initPromise;
+    private destroyPromise;
+    private readonly wrapperListeners;
+    private readonly autoInitiateCheckoutEnabled;
+    private publicOrderId;
+    private readonly publicContext;
+    private readonly noThanksUrl;
+    private checkoutStarted;
+    private lastLeadFingerprint;
+    private readonly selectedBumpIds;
+    constructor(options: BemonyPixelConstructOptions);
+    getScenario(): BemonyScenario;
+    getConfig(): Readonly<PixelConfig>;
+    getState(): BemonyPixelState;
+    isInitialized(): boolean;
+    getDebugSnapshot(): Readonly<PixelDebugSnapshot>;
+    /**
+     * `publicOrderId` do domínio do app (não mapeado para identity do Core).
+     * Fallback opcional: param `oid` da URL atual.
+     */
+    getPublicOrderId(): string | null;
+    /**
+     * Define `publicOrderId` e propaga para managed param `oid` quando suportado.
+     */
+    setPublicOrderId(orderId: string): void;
+    getPublicSessionId(): string | null;
+    selectOffer(input: BemonyOfferInput): void;
+    /**
+     * Inicia checkout → `Pixel.initiateCheckout()`.
+     * Idempotente: no máximo uma vez por lifecycle da instância.
+     */
+    startCheckout(input?: BemonyCheckoutInput): void;
+    /**
+     * Captura lead → `Pixel.lead()`.
+     * Campos incompletos não disparam. Mesmo fingerprint não reenvia (debounce).
+     */
+    captureLead(input: BemonyLeadInput): boolean;
+    selectOrderBump(input: BemonyOfferInput): void;
+    removeOrderBump(input: BemonyOfferInput): void;
+    trackPaymentMethod(input: BemonyPaymentMethodInput): void;
+    viewUpsell(input: BemonyOfferInput): void;
+    acceptUpsell(input: BemonyOfferInput): void;
+    /**
+     * Recusa de upsell/downsell — callback/navegação apenas.
+     * Destino: `navigateTo` explícito, senão `noThanksUrl` (data-no-thanks).
+     */
+    declineUpsell(options?: BemonyDeclineUpsellOptions): void;
+    /**
+     * Intenção de confirmação one-click → `Pixel.addToCart()`.
+     * Não processa pagamento e **não** emite PURCHASE.
+     */
+    trackOneClickConfirmation(input: BemonyOneClickConfirmationInput): void;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    addWrapperListener(cleanup: () => void): () => void;
+    private assertReady;
+    private assertOneClickReady;
+    private applyPublicOrderIdToManagedParam;
+    private decorateNavigateUrl;
+    private maybeAutoInitiateCheckout;
+    private resetDomainState;
+    private startInit;
+    private startDestroy;
+    private safeCoreDestroy;
+    private clearWrapperListeners;
+}
+
+/**
+ * Opções da factory de lifecycle.
+ * Sem contextResolver / catálogo remoto.
+ */
+type BemonyPixelOptions = CreateBemonyPixelConfigOptions & {
+    createCorePixel?: (config: PixelConfig) => BemonyCorePixel;
+};
+type CreateBemonyPixelOptions = BemonyPixelOptions;
+/**
+ * Bootstrap local (sem consulta de catálogo):
+ * 1. Normalizar cenário e contexto público
+ * 2. Journey UrlContext + managed params
+ * 3. PixelConfig
+ * 4. Core init + detectores
+ *
+ * O browser captura priceCode observado; o backend enriquece o evento.
+ */
+declare function createBemonyPixel(options: CreateBemonyPixelOptions): Promise<BemonyPixel>;
+
+export { BEMONY_PAYMENT_METHODS as A, type BemonyPublicPageContext as B, type CreateBemonyPixelConfigOptions as C, isValidBemonyPaymentMethod as D, type BemonyCheckoutInput as E, type BemonyEnvironment as F, BEMONY_ENVIRONMENTS as G, resolveBemonyEnvironment as H, type BemonyPlatformOptions as I, BEMONY_BROWSER_AUTO_INIT_DEFAULTS as J, BEMONY_DEFAULT_ALLOWED_DOMAINS as K, BEMONY_DEFAULT_API_ENDPOINT as L, BEMONY_DEFAULT_BROWSER_ENVIRONMENT as M, BEMONY_DEFAULT_BROWSER_SCENARIO as N, BEMONY_DEFAULT_NAMESPACE as O, BEMONY_DEFAULT_PIXEL_ID as P, BEMONY_PLATFORM_DEFAULTS as Q, type ResolvePriceCodeResult as R, BEMONY_STORAGE_PREFIX as S, type BemonyCommerceInput as T, type BemonyPageContextInput as U, type BemonyValidationErrorCode as V, BemonyValidationError as W, isBemonyPageContextInput as X, normalizeBemonyPageContextInput as Y, type BemonyScenario as a, type BemonyConfigOverrides as b, createBemonyPixelConfig as c, createBemonyPixel as d, type BemonyPixelOptions as e, type CreateBemonyPixelOptions as f, BemonyLifecycleError as g, BemonyPixel as h, type BemonyCorePixel as i, type BemonyLifecycleErrorCode as j, type BemonyPixelConstructOptions as k, type BemonyPixelState as l, BEMONY_SCENARIOS as m, type BemonyDeclineUpsellOptions as n, type BemonyOneClickConfirmationInput as o, type BemonyOfferInput as p, isCompleteBemonyOffer as q, resolvePriceCodeFromAcceptElement as r, type BemonyCommerceIdentityInput as s, resolvePriceCode as t, type BemonyLeadInput as u, isValidBemonyLead as v, leadFingerprint as w, sanitizeLeadFields as x, type BemonyPaymentMethodInput as y, type BemonyPaymentMethod as z };