@beworke/pixel 0.1.0-rc.1

package/dist/index.d.mts

@@ -0,0 +1,364 @@
+export { D as DEFAULT_PIXEL_CONFIG } from './pixel-default-config-1VgLFOiL.mjs';
+import { P as PixelConfig } from './pixel-CbeF25mD.mjs';
+export { r as resolveStorageAdapterName } from './StorageFactory-BhpbB6Jj.mjs';
+import { P as PixelEvent, i as PurchaseData, L as LeadData, j as AddToCartData, R as RemoveFromCartData, I as InitiateCheckoutData, k as AddPaymentInfoData, V as ViewContentData, l as SearchData, c as AttributionIdentifiers } from './index-DUfFzniE.mjs';
+import { P as PixelLogger } from './PixelLogger-B21lEjep.mjs';
+import { P as PixelRuntimeServices } from './types-DGlBdsAy.mjs';
+
+type DestinationResultStatus = 'success' | 'failed' | 'ignored' | 'retry' | 'skipped';
+type DestinationResult = {
+    readonly status: DestinationResultStatus;
+    readonly adapter: string;
+    readonly duration: number;
+    readonly timestamp: number;
+    readonly error?: string;
+    readonly ignored?: boolean;
+    readonly skipped?: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type DestinationMetricsSnapshot = {
+    readonly registeredDestinations: number;
+    readonly activeDestinations: number;
+    readonly eventsSent: number;
+    readonly eventsFailed: number;
+    readonly eventsIgnored: number;
+    readonly eventsSkipped: number;
+    readonly pageViewReceived: number;
+    readonly pageViewSent: number;
+    readonly pageViewSkipped: number;
+    readonly pageViewDeduped: number;
+    readonly pageViewFailed: number;
+    readonly scriptLoadAttempts: number;
+    readonly scriptLoadSuccess: number;
+    readonly scriptLoadFailure: number;
+    readonly initAttempts: number;
+    readonly initSuccess: number;
+    readonly initFailure: number;
+    readonly averageDuration: number;
+    readonly successRate: number;
+    readonly lastExecutionAt: number | null;
+    readonly lastErrorAt: number | null;
+    readonly lastErrorMessage: string | null;
+    readonly perDestination: Readonly<Record<string, {
+        readonly sent: number;
+        readonly failed: number;
+        readonly ignored: number;
+        readonly skipped: number;
+        readonly averageDuration: number;
+        readonly successRate: number;
+        readonly pageViewSent: number;
+        readonly pageViewDeduped: number;
+        readonly pageViewFailed: number;
+        readonly scriptLoadAttempts: number;
+        readonly scriptLoadSuccess: number;
+        readonly scriptLoadFailure: number;
+        readonly initAttempts: number;
+        readonly initSuccess: number;
+        readonly initFailure: number;
+        readonly lastError: string | null;
+    }>>;
+    readonly perDestinationId: Readonly<Record<string, {
+        readonly sent: number;
+        readonly failed: number;
+        readonly pageViewSent: number;
+        readonly pageViewDeduped: number;
+        readonly pageViewFailed: number;
+    }>>;
+};
+type IntegrationDebugState = {
+    readonly active: boolean;
+    readonly destinationNames: readonly string[];
+    readonly metrics: DestinationMetricsSnapshot;
+    readonly lastResults: readonly DestinationResult[];
+};
+
+type CompressionDebugState = {
+    readonly enabled: boolean;
+    readonly strategy: string;
+    readonly lastOriginalSize: number | null;
+    readonly lastCompressedSize: number | null;
+};
+
+type CoordinationDebugState = {
+    readonly enabled: boolean;
+    readonly tabId: string;
+    readonly isLeader: boolean;
+    readonly leaderTabId: string | null;
+    readonly tabCount: number;
+    readonly transport: 'broadcastChannel' | 'storageEvents' | 'none';
+};
+
+type DeadLetterReason = 'max_retries_exceeded' | 'circuit_open' | 'permanent_failure' | 'manual';
+type DeadLetterEntry = {
+    readonly id: string;
+    readonly events: readonly PixelEvent[];
+    readonly reason: DeadLetterReason;
+    readonly failedAt: number;
+    readonly attempts: number;
+    readonly lastError?: string;
+};
+type DeadLetterDebugState = {
+    readonly enabled: boolean;
+    readonly count: number;
+    readonly maxEntries: number;
+    readonly entries: readonly DeadLetterEntry[];
+};
+
+type BatchConfig = {
+    readonly batchSize: number;
+    readonly flushIntervalMs: number;
+    readonly maxWaitMs: number;
+};
+type BatchDebugState = {
+    readonly bufferSize: number;
+    readonly oldestEventAt: number | null;
+    readonly pendingBatches: number;
+};
+interface IBatchManager {
+    add(events: readonly PixelEvent[]): void;
+    takeBatch(maxSize?: number): PixelEvent[];
+    peek(): readonly PixelEvent[];
+    size(): number;
+    clear(): void;
+    shouldFlush(config: BatchConfig): boolean;
+    getState(): BatchDebugState;
+}
+
+type FlushDebugState = {
+    readonly flushCount: number;
+    readonly lastFlushAt: number | null;
+    readonly intervalActive: boolean;
+};
+interface IFlushManager {
+    init(onFlush: () => void): void;
+    flush(): void;
+    destroy(): void;
+    getState(): FlushDebugState;
+}
+
+type OfflineDebugState = {
+    readonly isOnline: boolean;
+    readonly paused: boolean;
+    readonly simulatedOffline: boolean;
+};
+interface IOfflineDetector {
+    init(onOnline: () => void, onOffline: () => void): void;
+    isOnline(): boolean;
+    isPaused(): boolean;
+    destroy(): void;
+    /** @internal Testes e playground apenas. */
+    simulateOffline(offline: boolean): void;
+    getState(): OfflineDebugState;
+}
+
+type RetryTask = () => Promise<void>;
+type RetryAttemptState = {
+    readonly id: string;
+    readonly attempt: number;
+    readonly nextRetryAt: number | null;
+    readonly status: 'pending' | 'running' | 'scheduled' | 'completed' | 'failed' | 'cancelled';
+};
+type RetryDebugState = {
+    readonly pendingCount: number;
+    readonly attempts: readonly RetryAttemptState[];
+};
+interface IRetryEngine {
+    retry(task: RetryTask, taskId?: string): Promise<void>;
+    cancel(taskId: string): void;
+    cancelAll(): void;
+    getState(): RetryDebugState;
+}
+
+type SendOptions = {
+    readonly signal?: AbortSignal;
+};
+type SendResult = {
+    readonly ack: boolean;
+    readonly eventCount: number;
+};
+interface EventSender {
+    send(events: PixelEvent[], options?: SendOptions): Promise<SendResult>;
+}
+
+type DeliveryConfig = {
+    readonly batch: BatchConfig;
+    readonly timeoutMs: number;
+};
+type DeliveryDebugState = {
+    readonly batch: ReturnType<IBatchManager['getState']>;
+    readonly retry: ReturnType<IRetryEngine['getState']>;
+    readonly offline: ReturnType<IOfflineDetector['getState']>;
+    readonly flush: ReturnType<IFlushManager['getState']>;
+    readonly timeoutMs: number;
+    readonly inFlight: boolean;
+    readonly ackCount: number;
+};
+declare class TransportDelivery {
+    private readonly batchManager;
+    private readonly flushManager;
+    private readonly retryEngine;
+    private readonly offlineDetector;
+    private readonly sender;
+    private readonly config;
+    private readonly logger;
+    private active;
+    private inFlight;
+    private ackCount;
+    private abortPending;
+    private readonly onPermanentFailure;
+    constructor(deps: {
+        batchManager: IBatchManager;
+        flushManager: IFlushManager;
+        retryEngine: IRetryEngine;
+        offlineDetector: IOfflineDetector;
+        sender: EventSender;
+        config: DeliveryConfig;
+        logger: PixelLogger;
+        abortPending?: () => void;
+        onPermanentFailure?: (events: readonly PixelEvent[], error: unknown) => void;
+    });
+    init(): void;
+    destroy(): void;
+    ingest(events: readonly PixelEvent[]): void;
+    flush(): void;
+    getDebugState(): DeliveryDebugState;
+    getOfflineDetector(): IOfflineDetector;
+    private processBatch;
+}
+
+type OrderingDebugState = {
+    readonly enabled: boolean;
+    readonly globalSequence: number;
+    readonly sessionSequence: number;
+    readonly lastCorrelationId: string | null;
+    readonly recordCount: number;
+};
+
+type BackpressurePolicy = 'drop_oldest' | 'drop_newest' | 'reject_new' | 'sample' | 'none';
+type BackpressureDebugState = {
+    readonly enabled: boolean;
+    readonly currentSize: number;
+    readonly maxQueueSize: number;
+    readonly policy: BackpressurePolicy;
+    readonly totalDropped: number;
+    readonly totalRejected: number;
+    readonly totalSampled: number;
+};
+
+type ReplayTrigger = 'init' | 'reload' | 'reconnect' | 'restart' | 'manual';
+type ReplayDebugState = {
+    readonly enabled: boolean;
+    readonly lastTrigger: ReplayTrigger | null;
+    readonly lastReplayAt: number | null;
+    readonly totalReplayed: number;
+    readonly pendingCount: number;
+};
+
+type CircuitBreakerState = 'closed' | 'open' | 'half_open';
+type CircuitBreakerMetrics = {
+    readonly state: CircuitBreakerState;
+    readonly consecutiveFailures: number;
+    readonly totalFailures: number;
+    readonly totalSuccesses: number;
+    readonly totalBlocked: number;
+    readonly lastFailureAt: number | null;
+    readonly lastSuccessAt: number | null;
+    readonly openedAt: number | null;
+};
+
+type TransportAdvancedDebugState = {
+    readonly storage: {
+        readonly adapter: string;
+        readonly persistenceEnabled: boolean;
+        readonly recordCount: number;
+    };
+    readonly replay: ReplayDebugState;
+    readonly ordering: OrderingDebugState;
+    readonly coordination: CoordinationDebugState;
+    readonly circuitBreaker: CircuitBreakerMetrics;
+    readonly backpressure: BackpressureDebugState;
+    readonly deadLetter: DeadLetterDebugState;
+    readonly compression: CompressionDebugState;
+    readonly senderMode: 'mock' | 'http';
+};
+type TransportDebugState = {
+    readonly queueSize: number;
+    readonly queueContents: readonly PixelEvent[];
+    readonly pipelineSteps: readonly string[];
+    readonly senderLogs: readonly string[];
+    readonly sentCount: number;
+    readonly delivery: ReturnType<TransportDelivery['getDebugState']> | null;
+    readonly sender: Record<string, unknown> | null;
+    readonly advanced: TransportAdvancedDebugState | null;
+};
+
+declare class Pixel {
+    private readonly runtime;
+    private readonly conversionModule;
+    private readonly transportModule;
+    private readonly integrationsModule;
+    constructor(config: PixelConfig);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isInitialized(): boolean;
+    purchase(data: PurchaseData): void;
+    lead(data: LeadData): void;
+    addToCart(data: AddToCartData): void;
+    removeFromCart(data: RemoveFromCartData): void;
+    initiateCheckout(data: InitiateCheckoutData): void;
+    addPaymentInfo(data: AddPaymentInfoData): void;
+    viewContent(data: ViewContentData): void;
+    search(data: SearchData): void;
+    /** @internal For playground and development only. */
+    getDebugDedupeKeys(): readonly string[];
+    /** @internal For playground and development only. */
+    getDebugActiveDetectors(): readonly string[];
+    /** @internal For playground and development only. */
+    getDebugTransportState(): TransportDebugState | null;
+    /** @internal For playground — flush manual do transport. */
+    flushTransport(): void;
+    /** @internal For playground — simular offline. */
+    simulateTransportOffline(offline: boolean): void;
+    /** @internal For playground — forçar falhas no MockSender (retry). */
+    configureTransportMockSender(options: {
+        delayMs?: number;
+        failUntilAttempt?: number;
+        simulateTimeout?: boolean;
+    }): void;
+    /** @internal For playground — simular reload da página. */
+    simulateTransportReload(): Promise<void>;
+    /** @internal For playground — simular restart do transport. */
+    simulateTransportRestart(): Promise<void>;
+    /** @internal For playground — abrir circuit breaker. */
+    forceTransportCircuitOpen(): void;
+    /** @internal For playground — fechar circuit breaker. */
+    forceTransportCircuitClose(): void;
+    /** @internal For playground — replay manual da fila persistida. */
+    manualTransportReplay(): Promise<number>;
+    /** @internal For playground — replay dead letter. */
+    replayTransportDeadLetter(): PixelEvent[];
+    /** @internal For playground — limpar dead letter. */
+    clearTransportDeadLetter(): void;
+    /** @internal For playground — exportar fila. */
+    exportTransportQueue(): string;
+    /** @internal For playground — importar fila. */
+    importTransportQueue(raw: string): number;
+    /** @internal For playground — Integration Engine debug state. */
+    getDebugIntegrationState(): IntegrationDebugState | null;
+    /** @internal For playground — MemoryDestination records. */
+    getDebugIntegrationMemoryRecords(): readonly {
+        readonly at: number;
+        readonly type: string;
+        readonly payload: Readonly<Record<string, unknown>>;
+    }[];
+    /** @internal For playground — Attribution snapshot. */
+    getDebugAttributionSnapshot(): AttributionIdentifiers | null;
+    /** @internal For playground — recolher attribution. */
+    collectAttribution(): AttributionIdentifiers | null;
+    /** @internal For playground — limpar attribution. */
+    clearAttribution(): void;
+    /** @internal For playground and development only. Not part of the stable public API. */
+    getDebugServices(): PixelRuntimeServices | null;
+}
+
+export { Pixel, PixelConfig };