saasco-sdk 0.1.43 → 0.1.44

package/index.esm.js

@@ -1,10 +1,10 @@
 import { __awaiter } from 'tslib';
 import { isValid, parse } from 'psl';
-import { sha256 } from 'js-sha256';
 import { v4 } from '@lukeed/uuid';
+import { sha256 } from 'js-sha256';
 import { z } from 'zod';
 
-var version = "0.1.43";
+var version = "0.1.44";
 
 const timezones = {
   'Asia/Barnaul': 'RU',
@@ -551,26 +551,117 @@ function getBrowserContext() {
   };
 }
 
-const isBrowser$2 = typeof window !== 'undefined';
-const isServer$2 = !isBrowser$2;
+var LogLevel;
+(function (LogLevel) {
+  LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+  LogLevel[LogLevel["WARN"] = 1] = "WARN";
+  LogLevel[LogLevel["INFO"] = 2] = "INFO";
+  LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+class AnalyticsLogger {
+  constructor(config) {
+    this.config = config;
+  }
+  debug(...args) {
+    if (this.config.level < LogLevel.DEBUG) return;
+    const icon = '◍';
+    const message = `${icon} ${this.config.label}`;
+    console.debug(`%c ${message}`, `background: #eee; color: #000; padding-right: 6px; border-radius: 2px;`, ...args);
+  }
+  /**
+   * Log debug information
+   */
+  info(...args) {
+    if (this.config.level < LogLevel.INFO) return;
+    const icon = '◍';
+    const message = `${icon} ${this.config.label}`;
+    console.info(`%c ${message}`, `background: #eee; color: #000; padding-right: 6px; border-radius: 2px;`, ...args);
+  }
+  /**
+   * Log warning information
+   */
+  warn(...args) {
+    if (this.config.level < LogLevel.WARN) return;
+    const icon = '◍';
+    const message = `${icon} ${this.config.label}`;
+    console.warn(`%c ${message}`, `background: #ffa500; color: #000; padding-right: 6px; border-radius: 2px;`, ...args);
+  }
+  /**
+   * Log error information
+   */
+  error(...args) {
+    const icon = '◍';
+    const message = `${icon} ${this.config.label} Error`;
+    console.error(`%c ${message}`, 'background: red; color: white; padding-right: 6px; border-radius: 2px;', ...args);
+    return {
+      success: false,
+      message: args.join(' ')
+    };
+  }
+}
+
+const isBrowser$4 = typeof window !== 'undefined';
+const isServer$4 = !isBrowser$4;
+/**
+ * Get the logger level for a specific integration
+ * Supports URL parameters like saasco-debug-{integration-type}=true
+ * If debug is true or URL param is true, sets level to DEBUG (3), otherwise WARN
+ */
+function getIntegrationLoggerLevel(integrationName, debug) {
+  // Check URL parameters for debug overrides (browser only)
+  let urlDebug = false;
+  if (!isServer$4) {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const paramName = `saasco-debug-${integrationName}`;
+      const paramValue = urlParams.get(paramName);
+      if (paramValue === 'true') {
+        urlDebug = true;
+      }
+    } catch (error) {
+      // Ignore URL parsing errors
+    }
+  }
+  // URL parameters override config, config overrides default (WARN)
+  return urlDebug || debug ? LogLevel.DEBUG : LogLevel.WARN;
+}
+
+/**
+ * Generate a collision-resistant UUID
+ * Uses lukeed's UUID v4 implementation for consistent, fast UUID generation
+ */
+function uuid() {
+  return v4();
+}
+
+const isBrowser$3 = typeof window !== 'undefined';
+const isServer$3 = !isBrowser$3;
 const standardFacebookEvents = ['AddPaymentInfo', 'AddToCart', 'AddToWishlist', 'CompleteRegistration', 'Contact', 'CustomizeProduct', 'Donate', 'FindLocation', 'InitiateCheckout', 'Lead', 'Purchase', 'Schedule', 'Search', 'StartTrial', 'SubmitApplication', 'Subscribe', 'ViewContent', 'PageView'];
 /**
  * Create a Facebook Pixel integration instance
  */
-function createFacebookPixelIntegration(config) {
+function createFacebookPixelIntegration(config, debug) {
   let isPixelReady = false;
+  // Create integration logger
+  const integrationLoggerLevel = getIntegrationLoggerLevel('facebook-pixel', debug);
+  const logger = new AnalyticsLogger({
+    level: integrationLoggerLevel,
+    label: 'Saasco facebook-pixel'
+  });
   return {
     name: 'facebook-pixel',
     environments: ['client'],
     init: () => __awaiter(this, void 0, void 0, function* () {
-      if (isServer$2) {
-        // On server, Facebook Pixel is a no-op but doesn't throw
-        // This allows the integration to be registered but remain inactive
+      if (isServer$3) {
+        logger.debug('Facebook Pixel init skipped on server');
         return;
       }
+      logger.info('Initializing Facebook Pixel', {
+        pixelId: config.pixelId
+      });
       // Check if Facebook Pixel is already loaded
       if (window.fbq || window._fbq) {
-        console.warn('Facebook Pixel is already initialized');
+        logger.warn('Facebook Pixel is already initialized');
         isPixelReady = true;
         return;
       }
@@ -593,9 +684,11 @@ function createFacebookPixelIntegration(config) {
             // Add load event listener
             t.onload = () => {
               isPixelReady = true;
+              logger.info('Facebook Pixel script loaded successfully');
               resolve();
             };
             t.onerror = () => {
+              logger.error('Failed to load Facebook Pixel script');
               reject(new Error('Failed to load Facebook Pixel script'));
             };
             s = b.getElementsByTagName(e)[0];
@@ -606,33 +699,56 @@ function createFacebookPixelIntegration(config) {
           // Allow duplicate PageView events
           window.fbq.allowDuplicatePageViews = true;
           if (config.automaticConfiguration === false) {
+            logger.debug('Disabling automatic configuration');
             window.fbq('set', 'autoConfig', false, config.pixelId);
           }
           // Initialize pixel
+          logger.debug('Initializing Facebook Pixel with ID', config.pixelId);
           window.fbq('init', config.pixelId);
           // If script loads synchronously, mark as ready
           if (window.fbq && typeof window.fbq === 'function') {
             isPixelReady = true;
+            logger.info('Facebook Pixel initialized synchronously');
             resolve();
           }
         } catch (error) {
+          logger.error('Error during Facebook Pixel initialization', error);
           reject(error);
         }
       });
     }),
     track: (eventName, properties, context) => {
-      if (!isPixelReady || !window.fbq) return;
+      if (!isPixelReady || !window.fbq) {
+        logger.warn('Facebook Pixel not ready, skipping track event', {
+          eventName
+        });
+        return;
+      }
       const fbEventName = getFacebookEventName(eventName, config.eventMapping);
       const eventsWithParams = ['Purchase', 'StartTrial', 'Subscribe'];
       const isStandardEvent = standardFacebookEvents.includes(fbEventName);
       const trackType = isStandardEvent ? 'track' : 'trackCustom';
+      logger.debug('Tracking Facebook Pixel event', {
+        originalEvent: eventName,
+        fbEventName,
+        trackType,
+        isStandardEvent,
+        properties
+      });
       if (eventsWithParams.includes(fbEventName) && properties) {
         const fbParams = {};
         if (properties['value'] !== undefined) fbParams['value'] = properties['value'];
         if (properties['currency'] !== undefined) fbParams['currency'] = properties['currency'];
         if (properties['predicted_ltv'] !== undefined) fbParams['predicted_ltv'] = properties['predicted_ltv'];
+        logger.info('Tracking Facebook Pixel event with parameters', {
+          event: fbEventName,
+          params: fbParams
+        });
         window.fbq(trackType, fbEventName, fbParams);
       } else {
+        logger.info('Tracking Facebook Pixel event', {
+          event: fbEventName
+        });
         window.fbq(trackType, fbEventName);
       }
     },
@@ -798,7 +914,7 @@ function coerceMetaConversionsAmValues(properties) {
     coerceFrom,
     transform
   } of coerce) {
-    const foundValue = findFirstProperty$1(properties, coerceFrom);
+    const foundValue = findFirstProperty$2(properties, coerceFrom);
     if (foundValue !== null && transform) {
       const transformedValue = transform(foundValue);
       if (transformedValue) {
@@ -810,6 +926,183 @@ function coerceMetaConversionsAmValues(properties) {
   }
   return result;
 }
+function findFirstProperty$2(properties, keys) {
+  for (const key of keys) {
+    if (properties[key] !== undefined) {
+      return properties[key];
+    }
+  }
+  return null;
+}
+
+const isBrowser$2 = typeof window !== 'undefined';
+const isServer$2 = !isBrowser$2;
+/**
+ * Standard Pinterest events
+ * Reference: https://www.pinterest.com/_/_/help/business/article/event-code
+ */
+const standardPinterestEvents = ['checkout', 'addtocart', 'pagevisit', 'signup', 'watchvideo', 'lead', 'search', 'viewcategory', 'custom', 'addpaymentinfo', 'addtowishlist', 'initiatecheckout', 'subscribe', 'viewcontent'];
+/**
+ * Create a Pinterest Tag integration instance
+ * Documentation: https://help.pinterest.com/en/business/article/install-the-pinterest-tag
+ */
+function createPinterestTagIntegration(config, debug) {
+  let isTagReady = false;
+  // Create integration logger
+  const integrationLoggerLevel = getIntegrationLoggerLevel('pinterest-tag', debug);
+  const logger = new AnalyticsLogger({
+    level: integrationLoggerLevel,
+    label: 'Saasco Pinterest Tag'
+  });
+  return {
+    name: 'pinterest-tag',
+    environments: ['client'],
+    init: context => __awaiter(this, void 0, void 0, function* () {
+      if (isServer$2) {
+        logger.debug('Pinterest Tag init skipped on server');
+        return;
+      }
+      logger.info('Initializing Pinterest Tag', {
+        tagId: config.tagId
+      });
+      // Check if Pinterest Tag is already loaded
+      if (window.pintrk || window._pintrk) {
+        logger.warn('Pinterest Tag is already initialized');
+        isTagReady = true;
+        return;
+      }
+      // Initialize Pinterest Tag
+      return new Promise((resolve, reject) => {
+        try {
+          // Pinterest Tag initialization script
+          // Reference: https://help.pinterest.com/en/business/article/install-the-base-code
+          (function (e) {
+            if (!window.pintrk) {
+              window.pintrk = function () {
+                window.pintrk.queue.push(Array.prototype.slice.call(arguments));
+              };
+              const n = window.pintrk;
+              n.queue = [];
+              n.version = '3.0';
+              const t = document.createElement('script');
+              t.async = true;
+              t.src = e;
+              // Add load event listener
+              t.onload = () => {
+                // base script is loaded; now (re)load tag + fire page via runtime
+                window.pintrk('load', config.tagId);
+                // initialize the tag
+                window.pintrk('page');
+                // delay isTagReady to ensure the tag is loaded before sending events
+                setTimeout(() => {
+                  logger.debug('Pinterest Tag initialized');
+                  isTagReady = true;
+                  resolve();
+                }, 500);
+              };
+              t.onerror = () => {
+                logger.error('Failed to load Pinterest Tag script');
+                reject(new Error('Failed to load Pinterest Tag script'));
+              };
+              const r = document.getElementsByTagName('script')[0];
+              r.parentNode.insertBefore(t, r);
+            }
+          })('https://s.pinimg.com/ct/core.js');
+        } catch (error) {
+          logger.error('Failed to initialize Pinterest Tag', error);
+          reject(error);
+        }
+      });
+    }),
+    track: (eventName, properties, context) => {
+      if (!isTagReady || !window.pintrk) return;
+      const pinterestEventName = getPinterestEventName(eventName, config.eventMapping);
+      const eventData = buildEventData(properties);
+      // Get enhanced matching data from properties
+      const enhancedMatchData = getPinterestEnhancedMatchData(context || {});
+      logger.debug('Tracking event', {
+        eventName,
+        pinterestEventName,
+        eventData,
+        enhancedMatchData
+      });
+      // Combine event data with enhanced matching data
+      const finalEventData = Object.assign(Object.assign({}, eventData), enhancedMatchData);
+      // Track the event
+      window.pintrk('track', pinterestEventName, finalEventData);
+    },
+    identify: (userId, properties, context) => {
+      // Identify not supported with pinterest tag
+      logger.debug('Identify not supported with pinterest tag', {
+        userId,
+        properties,
+        context
+      });
+      window.pintrk('set', {
+        external_id: userId
+      });
+      window.pintrk('set', {
+        em: properties === null || properties === void 0 ? void 0 : properties['email']
+      });
+      return;
+    }
+  };
+}
+function getPinterestEventName(eventName, eventMapping) {
+  // Convert default saasco Page View event by default
+  if (eventName === 'Page View') return 'pagevisit';
+  if (!eventMapping) return eventName.toLowerCase();
+  return eventMapping[eventName] || eventName.toLowerCase();
+}
+/**
+ * Build event data for Pinterest tracking
+ * Reference: https://www.pinterest.com/_/_/help/business/article/event-code
+ */
+function buildEventData(properties) {
+  if (!properties) return {};
+  const eventData = {};
+  // Map common properties to Pinterest event data
+  if (properties['event_id']) eventData['event_id'] = properties['event_id'];
+  if (properties['value']) eventData['value'] = properties['value'];
+  if (properties['currency']) eventData['currency'] = properties['currency'];
+  if (properties['order_quantity']) eventData['order_quantity'] = properties['order_quantity'];
+  if (properties['order_id']) eventData['order_id'] = properties['order_id'];
+  if (properties['promo_code']) eventData['promo_code'] = properties['promo_code'];
+  if (properties['property']) eventData['property'] = properties['property'];
+  if (properties['search_query']) eventData['search_query'] = properties['search_query'];
+  if (properties['video_title']) eventData['video_title'] = properties['video_title'];
+  if (properties['lead_type']) eventData['lead_type'] = properties['lead_type'];
+  if (properties['product_category']) eventData['product_category'] = properties['product_category'];
+  // Handle line items for e-commerce tracking
+  if (properties['line_items'] && Array.isArray(properties['line_items'])) {
+    eventData['line_items'] = properties['line_items'];
+  }
+  // Generate event_id if not provided
+  if (!eventData['event_id']) {
+    eventData['event_id'] = uuid();
+  }
+  return eventData;
+}
+/**
+ * Get Pinterest Enhanced Matching values from properties
+ * Reference: https://help.pinterest.com/en/business/article/enhanced-match
+ */
+function getPinterestEnhancedMatchData(properties) {
+  const enhancedMatch = {};
+  // Email
+  const email = findFirstProperty$1(properties, ['email', 'user_email', 'userEmail', 'email_address', 'emailAddress', 'e_mail', 'E_Mail', 'mail', 'Mail', 'contact_email', 'contactEmail', 'primary_email', 'primaryEmail']);
+  if (email && typeof email === 'string') {
+    // Pinterest expects hashed email for enhanced matching
+    const normalizedEmail = email.trim().toLowerCase();
+    enhancedMatch.em = normalizedEmail;
+  }
+  // External ID (User ID)
+  const externalId = findFirstProperty$1(properties, ['external_id', 'externalId', 'user_id', 'userId', 'id', 'distinctId', 'distinct_id', 'customer_id', 'customerId', 'member_id', 'memberId']);
+  if (externalId) {
+    enhancedMatch.external_id = String(externalId);
+  }
+  return enhancedMatch;
+}
 function findFirstProperty$1(properties, keys) {
   for (const key of keys) {
     if (properties[key] !== undefined) {
@@ -845,20 +1138,28 @@ const standardTikTokEvents = ['AddPaymentInfo', 'AddToCart', 'AddToWishlist', 'A
 /**
  * Create a TikTok Pixel integration instance
  */
-function createTikTokPixelIntegration(config) {
+function createTikTokPixelIntegration(config, debug) {
   let isPixelReady = false;
+  // Create integration logger
+  const integrationLoggerLevel = getIntegrationLoggerLevel('tiktok-pixel', debug);
+  const logger = new AnalyticsLogger({
+    level: integrationLoggerLevel,
+    label: 'Saasco tiktok-pixel'
+  });
   return {
     name: 'tiktok-pixel',
     environments: ['client'],
     init: () => __awaiter(this, void 0, void 0, function* () {
       if (isServer$1) {
-        // On server, TikTok Pixel is a no-op but doesn't throw
-        // This allows the integration to be registered but remain inactive
+        logger.debug('TikTok Pixel init skipped on server');
         return;
       }
+      logger.info('Initializing TikTok Pixel', {
+        pixelId: config.pixelId
+      });
       // Check if TikTok Pixel is already loaded
       if (window.ttq) {
-        console.warn('TikTok Pixel is already initialized');
+        logger.warn('TikTok Pixel is already initialized');
         isPixelReady = true;
         return;
       }
@@ -909,7 +1210,6 @@ function createTikTokPixelIntegration(config) {
             ttq.load(config.pixelId, config.testMode ? {
               test_mode: true
             } : undefined);
-            ttq.page();
             // If script loads synchronously, mark as ready
             if (window.ttq && typeof window.ttq === 'function') {
               isPixelReady = true;
@@ -1084,69 +1384,9 @@ function mapTikTokEventParameters(eventName, properties) {
   return Object.keys(params).length > 0 ? params : null;
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-class AnalyticsLogger {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Log debug information
-   */
-  log(...args) {
-    if (!this.config.debug) return;
-    const icon = '◍';
-    const message = `${icon} ${this.config.label}`;
-    console.info(`%c ${message}`, `background: #eee; color: #000; padding-right: 6px; border-radius: 2px;`, ...args);
-  }
-  /**
-   * Log warning information
-   */
-  warn(...args) {
-    if (!this.config.debug) return;
-    const icon = '◍';
-    const message = `${icon} ${this.config.label}`;
-    console.warn(`%c ${message}`, `background: #ffa500; color: #000; padding-right: 6px; border-radius: 2px;`, ...args);
-  }
-  /**
-   * Log error information
-   */
-  error(...args) {
-    const icon = '◍';
-    const message = `${icon} ${this.config.label} Error`;
-    console.error(`%c ${message}`, 'background: red; color: white; padding-right: 6px; border-radius: 2px;', ...args);
-    return {
-      success: false,
-      message: args.join(' ')
-    };
-  }
-}
-
-/**
- * Generate a collision-resistant UUID
- * Uses lukeed's UUID v4 implementation for consistent, fast UUID generation
- */
-function uuid() {
-  return v4();
-}
-
 /*
   Minimal analytics integration manager (v0)
 */
-class Logger {
-  constructor(label = 'Analytics', debug = false) {
-    this.label = label;
-    this.debug = debug;
-  }
-  log(...args) {
-    if (this.debug) console.log(`[${this.label}]`, ...args);
-  }
-  warn(...args) {
-    console.warn(`[${this.label}]`, ...args);
-  }
-  error(...args) {
-    console.error(`[${this.label}]`, ...args);
-  }
-}
 class IntegrationManager {
   constructor(config = {}) {
     var _a, _b, _c, _d;
@@ -1154,14 +1394,14 @@ class IntegrationManager {
     this.integrations = new Map();
     this.globalQueue = [];
     this.config = {
-      debug: (_a = config.debug) !== null && _a !== void 0 ? _a : false,
+      loggerLevel: (_a = config.loggerLevel) !== null && _a !== void 0 ? _a : LogLevel.ERROR,
       maxQueueSize: (_b = config.maxQueueSize) !== null && _b !== void 0 ? _b : 200,
       maxIntegrationWaitTime: (_c = config.maxIntegrationWaitTime) !== null && _c !== void 0 ? _c : 10000,
       flushInterval: (_d = config.flushInterval) !== null && _d !== void 0 ? _d : 5000
     };
     this.logger = new AnalyticsLogger({
       label: 'Saasco Integrations Debug',
-      debug: this.config.debug
+      level: this.config.loggerLevel
     });
     this.initTime = Date.now();
     this.currentEnvironment = typeof window !== 'undefined' ? 'client' : 'server';
@@ -1174,7 +1414,7 @@ class IntegrationManager {
   setContext(next) {
     this.context = Object.assign(Object.assign({}, this.context), next);
     // Only log if we are setting something
-    if (Object.keys(this.context).length > 0) this.logger.log('context', this.context);
+    if (Object.keys(this.context).length > 0) this.logger.info('setContext', this.context);
   }
   /**
    * Register and init an integration. When init resolves, we mark it ready and
@@ -1182,17 +1422,18 @@ class IntegrationManager {
    */
   registerIntegration(integration) {
     return __awaiter(this, void 0, void 0, function* () {
+      this.logger.debug('Register integrations', this.integrations);
       if (this.integrations.has(integration.name)) {
-        this.logger.warn(`integration already registered: ${integration.name}`);
+        this.logger.warn(`Integration already registered: ${integration.name}`);
         return;
       }
       // Check environment compatibility
       const isCompatible = integration.environments.includes(this.currentEnvironment);
       if (!isCompatible) {
-        this.logger.warn(`skipping ${integration.name}: requires ${integration.environments.join(' or ')} but running in ${this.currentEnvironment}`);
+        this.logger.warn(`Skipping ${integration.name}: requires ${integration.environments.join(' or ')} but running in ${this.currentEnvironment}`);
         return;
       }
-      this.logger.log(`registering ${integration.name})`);
+      this.logger.debug(`Registering ${integration.name}`);
       const state = {
         integration,
         status: 'idle'
@@ -1201,17 +1442,21 @@ class IntegrationManager {
       if (integration.init) {
         try {
           state.status = 'loading';
-          yield integration.init();
+          const startTime = Date.now();
+          this.logger.debug(`Initializing ${integration.name}`);
+          yield integration.init(this.context);
           state.status = 'ready';
-          this.logger.log(`${integration.name} integration ready`);
+          const endTime = Date.now();
+          const duration = endTime - startTime;
+          this.logger.debug(`Integration ${integration.name} ready in ${duration}ms`);
           this.flush();
         } catch (e) {
           state.status = 'error';
-          this.logger.error(`failed to init ${integration.name}`, e);
+          this.logger.error(`Failed to init ${integration.name}`, e);
         }
       } else {
         state.status = 'ready';
-        this.logger.log(`ready (no init) ${integration.name}`);
+        this.logger.info(`Integration ${integration.name} ready (no init)`);
         this.flush();
       }
     });
@@ -1252,10 +1497,10 @@ class IntegrationManager {
       if (this.globalQueue.length >= this.config.maxQueueSize) {
         // drop oldest
         this.globalQueue.shift();
-        this.logger.warn('queue full → dropped oldest');
+        this.logger.warn('Queue full → dropped oldest');
       }
       this.globalQueue.push(envelope);
-      this.logger.log(`queued (${this.globalQueue.length})`, envelope);
+      this.logger.debug(`Queued (${this.globalQueue.length})`, envelope);
       return;
     }
     this.deliver(envelope);
@@ -1269,8 +1514,17 @@ class IntegrationManager {
         if (status !== 'ready') continue;
         try {
           if (evt.type === 'track' && integration.track && evt.name) {
+            this.logger.debug(`Track (${integration.name}) ${evt.name}`, {
+              properties: evt.properties,
+              context: evt.context
+            });
             yield integration.track(evt.name, evt.properties, evt.context);
           } else if (evt.type === 'identify' && integration.identify) {
+            this.logger.debug(`Identify (${integration.name})`, {
+              userId: evt.context.distinctId,
+              properties: evt.properties,
+              context: evt.context
+            });
             yield integration.identify(evt.context.distinctId, evt.properties, evt.context);
           }
         } catch (e) {
@@ -1287,7 +1541,7 @@ class IntegrationManager {
     if (this.globalQueue.length === 0) return;
     // If we're not ready don't flush
     if (!this.isReady()) return;
-    this.logger.log(`flushing ${this.globalQueue.length} queued events`);
+    this.logger.debug(`flushing ${this.globalQueue.length} queued events`);
     const toSend = this.globalQueue;
     this.globalQueue = [];
     // deliver all events
@@ -1299,8 +1553,14 @@ class IntegrationManager {
     return n;
   }
   isReady() {
+    const timeElapsed = Date.now() - this.initTime;
     // Return if integrations are not ready, or if we haven't waited the max integration wait time
-    if (this.readyCount() < this.integrations.size && Date.now() - this.initTime < this.config.maxIntegrationWaitTime) return false;
+    if (this.readyCount() < this.integrations.size && timeElapsed < this.config.maxIntegrationWaitTime) {
+      return false;
+    }
+    if (this.readyCount() < this.integrations.size) {
+      this.logger.info(`proceeding with ${this.readyCount()}/${this.integrations.size} integrations ready after ${timeElapsed}ms wait`);
+    }
     return true;
   }
   /**
@@ -1322,7 +1582,7 @@ class IntegrationManager {
       return;
     }
     this.unloadHandler = () => {
-      this.logger.log('page unloading, flushing remaining events');
+      this.logger.info('page unloading, flushing remaining events');
       this.flush();
     };
     // Use both beforeunload and pagehide for better coverage
@@ -1341,7 +1601,8 @@ class IntegrationManager {
       queueLength: this.globalQueue.length,
       readyCount: this.readyCount(),
       periodicFlushEnabled: this.config.flushInterval > 0,
-      flushInterval: this.config.flushInterval
+      flushInterval: this.config.flushInterval,
+      context: this.context
     };
   }
 }
@@ -1545,11 +1806,13 @@ class Saasco {
     this.config = config;
     this.lastPageViewPath = '';
     this.isInitialized = false;
+    const loggerLevel = getLoggerLevel(this.config);
     // Initialize logger
     this.logger = new AnalyticsLogger({
-      debug: !!this.config.debug,
+      level: loggerLevel,
       label: 'Saasco Debug'
     });
+    this.logger.info('Saasco started');
     if (!config.projectId) {
       this.logger.error("Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly.");
       return;
@@ -1564,19 +1827,19 @@ class Saasco {
     }, this.config.autoPageTracking);
     // Initialize integration manager
     this.integrationManager = new IntegrationManager({
-      debug: this.config.debug,
+      loggerLevel,
       maxQueueSize: 1000
     });
     // Set initial context
     this.integrationManager.setContext({});
     // Initialize integrations immediately (works on both client and server)
     this.initIntegrations().catch(error => {
-      this.logger.log('Error initializing integrations:', error);
+      this.logger.info('Error initializing integrations:', error);
     });
   }
   init() {
     if (this.isInitialized) {
-      this.logger.log('Saasco is already initialized. Please check your code to ensure that init() is not being called multiple times.');
+      this.logger.info('Saasco is already initialized. Please check your code to ensure that init() is not being called multiple times.');
       return;
     }
     // Export Saasco to the window object for easy access and debugging
@@ -1585,43 +1848,48 @@ class Saasco {
     }
     // Migrate existing localStorage data to cookies for cross-subdomain support
     migrateFromLocalStorage();
-    this.logger.log('Saasco initialized', this.config);
-    if (this.config.debug) this.logger.log('Debug mode active. This will log all events to the console.');
-    if (!this.config.enabled) this.logger.log(`Analytics is disabled. No requests will be sent to the server and no integrations will be initialized. ${this.config.debug ? 'Debug mode is active and will still log information.' : ''}`);
+    this.logger.info('Saasco initialized', this.config);
+    if (this.config.debug) this.logger.info('Debug mode active. This will log all events to the console.');
+    if (!this.config.enabled) this.logger.info(`Analytics is disabled. No requests will be sent to the server and no integrations will be initialized. ${this.config.debug ? 'Debug mode is active and will still log information.' : ''}`);
     this.initAutoPageTracking();
     this.isInitialized = true;
   }
   disableDebug() {
-    this.logger.log('Debug mode deactivated.');
+    this.logger.info('Debug mode deactivated.');
     this.config.debug = false;
   }
   enableDebug() {
     this.config.debug = true;
-    this.logger.log('Debug mode activated.');
+    this.logger.info('Debug mode activated.');
   }
   /**
    * Initialize third-party integrations
    */
   initIntegrations() {
     return __awaiter(this, void 0, void 0, function* () {
+      this.logger.info('Initialize integrations');
       if (!this.config.integrations || this.config.integrations.length === 0) return;
       if (!this.config.enabled) {
-        this.logger.log('Analytics is disabled. Skipping integration initialization.');
+        this.logger.info('Analytics is disabled. Skipping integration initialization.');
         return;
       }
       for (const integrationConfig of this.config.integrations) {
         try {
           if (integrationConfig.type === 'facebook-pixel') {
-            this.logger.log('Registering Facebook Pixel integration with ID:', integrationConfig.config.pixelId);
-            const fbIntegration = createFacebookPixelIntegration(integrationConfig.config);
+            this.logger.info('Registering Facebook Pixel integration with ID:', integrationConfig.config.pixelId);
+            const fbIntegration = createFacebookPixelIntegration(integrationConfig.config, integrationConfig.debug);
             yield this.integrationManager.registerIntegration(fbIntegration);
+          } else if (integrationConfig.type === 'pinterest-tag') {
+            this.logger.info('Registering Pinterest Tag integration with ID:', integrationConfig.config.tagId);
+            const pinterestIntegration = createPinterestTagIntegration(integrationConfig.config, integrationConfig.debug);
+            yield this.integrationManager.registerIntegration(pinterestIntegration);
           } else if (integrationConfig.type === 'tiktok-pixel') {
-            this.logger.log('Registering TikTok Pixel integration with ID:', integrationConfig.config.pixelId);
-            const tiktokIntegration = createTikTokPixelIntegration(integrationConfig.config);
+            this.logger.info('Registering TikTok Pixel integration with ID:', integrationConfig.config.pixelId);
+            const tiktokIntegration = createTikTokPixelIntegration(integrationConfig.config, integrationConfig.debug);
             yield this.integrationManager.registerIntegration(tiktokIntegration);
           }
         } catch (error) {
-          this.logger.log(`Failed to register ${integrationConfig.type} integration:`, error);
+          this.logger.info(`Failed to register ${integrationConfig.type} integration:`, error);
         }
       }
     });
@@ -1675,9 +1943,9 @@ class Saasco {
       context: JSON.stringify(context || {})
     };
     if (data.action === 'Page View') {
-      this.logger.log('Page View', window.location.href, data);
+      this.logger.info('Page View', window.location.href, data);
     } else {
-      this.logger.log('track', data);
+      this.logger.info('track', data);
     }
     if (!this.config.enabled) {
       return Promise.resolve({
@@ -1730,7 +1998,7 @@ class Saasco {
     // This should only be called when distinctId is null and there is an existing userId.
     // This means the user has logged out and we should reset the session and anonymous IDs
     const userIdChangedToNull = distinctId === null && !!getUserId();
-    if (userIdChangedToNull) this.logger.log('User logged out');
+    if (userIdChangedToNull) this.logger.info('User logged out');
     const reset = userIdChangedToNull;
     const sessionId = setSessionId({
       reset
@@ -1741,11 +2009,11 @@ class Saasco {
     // set the distinct Id to the userId
     setUserId(distinctId);
     // Update integration manager context and send identify (IntegrationManager will filter by environment)
-    this.integrationManager.setContext({
+    this.integrationManager.setContext(Object.assign({
       distinctId,
       anonymousId,
       sessionId
-    });
+    }, properties));
     // No distinctId provided so we don't track the user
     if (!distinctId) return Promise.resolve({
       success: true,
@@ -1762,7 +2030,7 @@ class Saasco {
       payload: properties || {},
       context: context || {}
     };
-    this.logger.log('identify', data);
+    this.logger.info('identify', data);
     // Only send identify to integrations if analytics is enabled
     if (!this.config.enabled) {
       return Promise.resolve({
@@ -1838,11 +2106,11 @@ class Saasco {
     if (isServer) return console.warn('Saasco auto page tracking is only available in the browser');
     // Prevent intitializing auto page tracking more than once
     if (window.saascoAutoPageTrackingActive) {
-      this.logger.log('Auto Page Tracking already enabled');
+      this.logger.info('Auto Page Tracking already enabled');
       return;
     }
     window.saascoAutoPageTrackingActive = true;
-    this.logger.log('Auto Page Tracking enabled');
+    this.logger.info('Auto Page Tracking enabled');
     // Track initial page load
     this.page();
     // Listen for hash changes if hash tracking is enabled
@@ -1866,6 +2134,27 @@ class Saasco {
       return returnValue;
     };
   }
+  getIntegrationsStats() {
+    return this.integrationManager.getStats();
+  }
+}
+function getLoggerLevel(config) {
+  // Check URL parameters for debug overrides (browser only)
+  let urlDebug = false;
+  let urlDebugVerbose = false;
+  if (!isServer) {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      urlDebug = urlParams.get('saasco-debug') === 'true';
+      urlDebugVerbose = urlParams.get('saasco-debug-verbose') === 'true';
+    } catch (error) {
+      // Ignore URL parsing errors
+    }
+  }
+  // URL parameters override config
+  const effectiveDebug = urlDebug || config.debug;
+  const effectiveDebugVerbose = urlDebugVerbose || config.debugVerbose;
+  return !!effectiveDebugVerbose ? LogLevel.DEBUG : !!effectiveDebug ? LogLevel.INFO : LogLevel.ERROR;
 }
 
 const browserContextSchema = z.object({
@@ -1893,4 +2182,4 @@ const browserContextSchema = z.object({
   $utmAdId: z.string().nullable()
 });
 
-export { IntegrationManager, Logger, Saasco, browserContextSchema, createFacebookPixelIntegration, createTikTokPixelIntegration, getBrowserContext, standardFacebookEvents, standardTikTokEvents, timezones };
+export { IntegrationManager, Saasco, browserContextSchema, createFacebookPixelIntegration, createPinterestTagIntegration, createTikTokPixelIntegration, getBrowserContext, standardFacebookEvents, standardPinterestEvents, standardTikTokEvents, timezones };