saasco-sdk 0.1.31 → 0.1.33

package/index.cjs.js

@@ -3,11 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var uuid = require('@lukeed/uuid');
 var psl = require('psl');
+var uuid$1 = require('@lukeed/uuid');
 var zod = require('zod');
 
-var version = "0.1.31";
+var version = "0.1.33";
 
 const timezones = {
   'Asia/Barnaul': 'RU',
@@ -554,6 +554,546 @@ function getBrowserContext() {
   };
 }
 
+const isBrowser$1 = typeof window !== 'undefined';
+const isServer$1 = !isBrowser$1;
+/**
+ * Create a Facebook Pixel integration instance
+ */
+function createFacebookPixelIntegration(config) {
+  let isPixelReady = false;
+  return {
+    name: 'facebook-pixel',
+    environments: ['client'],
+    init: () => tslib.__awaiter(this, void 0, void 0, function* () {
+      if (isServer$1) {
+        throw new Error('Facebook Pixel cannot be initialized on server');
+      }
+      // Check if Facebook Pixel is already loaded
+      if (window.fbq || window._fbq) {
+        console.warn('Facebook Pixel is already initialized');
+        isPixelReady = true;
+        return;
+      }
+      // Initialize Facebook Pixel
+      return new Promise((resolve, reject) => {
+        try {
+          (function (f, b, e, v, n, t, s) {
+            if (f.fbq) return;
+            n = f.fbq = function () {
+              n.callMethod ? n.callMethod.apply(n, arguments) : n.queue.push(arguments);
+            };
+            if (!f._fbq) f._fbq = n;
+            n.push = n;
+            n.loaded = !0;
+            n.version = '2.0';
+            n.queue = [];
+            t = b.createElement(e);
+            t.async = !0;
+            t.src = v;
+            // Add load event listener
+            t.onload = () => {
+              isPixelReady = true;
+              resolve();
+            };
+            t.onerror = () => {
+              reject(new Error('Failed to load Facebook Pixel script'));
+            };
+            s = b.getElementsByTagName(e)[0];
+            s.parentNode.insertBefore(t, s);
+          })(window, document, 'script', 'https://connect.facebook.net/en_US/fbevents.js');
+          // Initialize pixel (but don't track PageView automatically)
+          window.fbq('init', config.pixelId);
+          // If script loads synchronously, mark as ready
+          if (window.fbq && typeof window.fbq === 'function') {
+            isPixelReady = true;
+            resolve();
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }),
+    track: (eventName, properties, context) => {
+      if (!isPixelReady || !window.fbq) return;
+      const fbEventName = getFacebookEventName(eventName, config.eventMapping);
+      // Standard Facebook events that support parameters
+      const eventsWithParams = ['Purchase', 'StartTrial', 'Subscribe'];
+      if (eventsWithParams.includes(fbEventName) && properties) {
+        // Extract standard Facebook parameters
+        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'];
+        window.fbq('track', fbEventName, Object.assign(Object.assign({}, properties), fbParams));
+      } else {
+        window.fbq('track', fbEventName);
+      }
+    },
+    identify: (userId, properties, context) => tslib.__awaiter(this, void 0, void 0, function* () {
+      try {
+        if (typeof window !== 'undefined' && window.fbq) {
+          const amValues = coerceMetaConversionsAmValues(Object.assign(Object.assign({}, properties || {}), userId ? {
+            external_id: userId
+          } : {}));
+          const am = {};
+          if (amValues.external_id) am['external_id'] = amValues.external_id;
+          if (amValues.em) am['em'] = yield sha256Hex(amValues.em);
+          if (amValues.fn) am['fn'] = amValues.fn;
+          if (amValues.ln) am['ln'] = amValues.ln;
+          if (amValues.ph) am['ph'] = amValues.ph;
+          if (amValues.ge) am['ge'] = amValues.ge;
+          if (amValues.db) am['db'] = amValues.db;
+          if (amValues.ct) am['ct'] = amValues.ct;
+          if (amValues.st) am['st'] = amValues.st;
+          if (amValues.zp) am['zp'] = amValues.zp;
+          if (amValues.country) am['country'] = amValues.country;
+          if (Object.keys(am).length > 0) {
+            window.fbq('init', config.pixelId, am);
+          }
+        }
+      } catch (error) {
+        console.error('Error identifying user in Meta Pixel:', error);
+      }
+    })
+  };
+}
+function getFacebookEventName(eventName, eventMapping) {
+  // Convert default saasco page view event by default
+  if (eventName === 'Page View') return 'PageView';
+  if (!eventMapping) return eventName;
+  return eventMapping[eventName] || eventName;
+}
+// Legacy functions for backward compatibility (deprecated)
+function initializeFacebookPixel(pixelId) {
+  var _a;
+  console.warn('initializeFacebookPixel is deprecated. Use createFacebookPixelIntegration instead.');
+  const integration = createFacebookPixelIntegration({
+    pixelId
+  });
+  (_a = integration.init) === null || _a === void 0 ? void 0 : _a.call(integration);
+}
+function trackFacebookEvent(eventName, properties, eventMapping) {
+  console.warn('trackFacebookEvent is deprecated. Use IntegrationManager instead.');
+  if (isServer$1 || !window.fbq) return;
+  const fbEventName = getFacebookEventName(eventName, eventMapping);
+  const eventsWithParams = ['Purchase', 'StartTrial', 'Subscribe'];
+  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'];
+    window.fbq('track', fbEventName, fbParams);
+  } else {
+    window.fbq('track', fbEventName);
+  }
+}
+function coerceMetaConversionsAmValues(properties) {
+  const coerce = [{
+    key: 'em',
+    coerceFrom: ['email', 'user_email', 'userEmail', 'email_address', 'emailAddress', 'e_mail', 'E_Mail', 'mail', 'Mail', 'contact_email', 'contactEmail', 'primary_email', 'primaryEmail'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase();
+      return normalized || undefined;
+    }
+  }, {
+    key: 'fn',
+    coerceFrom: ['first_name', 'firstName', 'firstname', 'given_name', 'givenName', 'user_first_name', 'userFirstName', 'name_first', 'nameFirst', 'f_name', 'fName'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase();
+      return normalized || undefined;
+    }
+  }, {
+    key: 'ln',
+    coerceFrom: ['last_name', 'lastName', 'lastname', 'surname', 'user_last_name', 'userLastName', 'name_last', 'nameLast', 'l_name', 'lName'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase();
+      return normalized || undefined;
+    }
+  }, {
+    key: 'ph',
+    coerceFrom: ['phone', 'phone_number', 'phoneNumber', 'mobile', 'mobile_number', 'mobileNumber', 'contact_number', 'contactNumber', 'tel', 'telephone'],
+    transform: value => {
+      if (typeof value !== 'string' && typeof value !== 'number') return undefined;
+      const phoneStr = String(value).replace(/\D/g, '');
+      return phoneStr || undefined;
+    }
+  }, {
+    key: 'external_id',
+    coerceFrom: ['external_id', 'externalId', 'user_id', 'userId', 'id', 'distinctId', 'distinct_id', 'customer_id', 'customerId', 'member_id', 'memberId', 'loyalty_id', 'loyaltyId'],
+    transform: value => {
+      if (value == null) return undefined;
+      return String(value) || undefined;
+    }
+  }, {
+    key: 'ge',
+    coerceFrom: ['gender', 'user_gender', 'userGender', 'sex', 'user_sex', 'userSex'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase();
+      if (normalized === 'female' || normalized === 'f') return 'f';
+      if (normalized === 'male' || normalized === 'm') return 'm';
+      return undefined;
+    }
+  }, {
+    key: 'db',
+    coerceFrom: ['birthday', 'birth_date', 'birthDate', 'date_of_birth', 'dateOfBirth', 'dob', 'Dob', 'birth_day', 'birthDay'],
+    transform: value => {
+      if (!value) return undefined;
+      let dateStr;
+      if (value instanceof Date) {
+        dateStr = value.toISOString().split('T')[0];
+      } else {
+        dateStr = String(value);
+      }
+      const dateMatch = dateStr.match(/(\d{4})-(\d{2})-(\d{2})/);
+      if (dateMatch) {
+        const [, year, month, day] = dateMatch;
+        return `${year}${month}${day}`;
+      }
+      const numericMatch = dateStr.replace(/\D/g, '');
+      if (numericMatch.length === 8) {
+        return numericMatch;
+      }
+      return undefined;
+    }
+  }, {
+    key: 'ct',
+    coerceFrom: ['city', 'user_city', 'userCity', 'location_city', 'locationCity', 'address_city', 'addressCity'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase().replace(/\s+/g, '');
+      return normalized || undefined;
+    }
+  }, {
+    key: 'st',
+    coerceFrom: ['state', 'user_state', 'userState', 'province', 'user_province', 'userProvince', 'region', 'user_region', 'userRegion', 'location_state', 'locationState', 'address_state', 'addressState'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase();
+      if (normalized.length === 2) return normalized;
+      return undefined;
+    }
+  }, {
+    key: 'zp',
+    coerceFrom: ['zip', 'zipcode', 'zip_code', 'postal_code', 'postalCode', 'postcode', 'user_zip', 'userZip', 'address_zip', 'addressZip'],
+    transform: value => {
+      if (typeof value !== 'string' && typeof value !== 'number') return undefined;
+      return String(value).trim() || undefined;
+    }
+  }, {
+    key: 'country',
+    coerceFrom: ['country', 'country_code', 'countryCode', 'user_country', 'userCountry', 'location_country', 'locationCountry', 'address_country', 'addressCountry'],
+    transform: value => {
+      if (typeof value !== 'string') return undefined;
+      const normalized = value.trim().toLowerCase();
+      if (normalized.length === 2) return normalized;
+      return undefined;
+    }
+  }];
+  const result = {};
+  for (const {
+    key,
+    coerceFrom,
+    transform
+  } of coerce) {
+    const foundValue = findFirstProperty(properties, coerceFrom);
+    if (foundValue !== null && transform) {
+      const transformedValue = transform(foundValue);
+      if (transformedValue) {
+        result[key] = transformedValue;
+      }
+    } else if (foundValue !== null && typeof foundValue === 'string') {
+      result[key] = foundValue;
+    }
+  }
+  return result;
+}
+function findFirstProperty(properties, keys) {
+  for (const key of keys) {
+    if (properties[key] !== undefined) {
+      return properties[key];
+    }
+  }
+  return null;
+}
+const toHex = buf => [...new Uint8Array(buf)].map(b => b.toString(16).padStart(2, '0')).join('');
+function sha256Hex(input) {
+  return tslib.__awaiter(this, void 0, void 0, function* () {
+    const enc = new TextEncoder().encode(input);
+    const digest = yield crypto.subtle.digest('SHA-256', enc);
+    return toHex(digest);
+  });
+}
+
+/* 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 uuid$1.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;
+    this.context = {};
+    this.integrations = new Map();
+    this.globalQueue = [];
+    this.config = {
+      debug: (_a = config.debug) !== null && _a !== void 0 ? _a : false,
+      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
+    });
+    this.initTime = Date.now();
+    this.currentEnvironment = typeof window !== 'undefined' ? 'client' : 'server';
+    this.setupPeriodicFlushing();
+    this.setupUnloadHandler();
+  }
+  /**
+   * Shallow-merge context to keep it simple + predictable in v0
+   */
+  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);
+  }
+  /**
+   * Register and init an integration. When init resolves, we mark it ready and
+   * immediately flush any queued events in FIFO order to *all* ready integrations.
+   */
+  registerIntegration(integration) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+      if (this.integrations.has(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}`);
+        return;
+      }
+      this.logger.log(`registering ${integration.name} (supports: ${integration.environments.join(', ')}, current: ${this.currentEnvironment})`);
+      const state = {
+        integration,
+        status: 'idle'
+      };
+      this.integrations.set(integration.name, state);
+      if (integration.init) {
+        try {
+          state.status = 'loading';
+          this.logger.log(`init ${integration.name}`);
+          yield integration.init();
+          state.status = 'ready';
+          this.logger.log(`ready ${integration.name}`);
+          this.flush();
+        } catch (e) {
+          state.status = 'error';
+          this.logger.error(`failed to init ${integration.name}`, e);
+        }
+      } else {
+        state.status = 'ready';
+        this.logger.log(`ready (no init) ${integration.name}`);
+        this.flush();
+      }
+    });
+  }
+  identify(userId, traits) {
+    // update context so subsequent track() carries new userId
+    this.setContext({
+      userId
+    });
+    this.send({
+      type: 'identify',
+      name: undefined,
+      properties: traits
+    });
+  }
+  track(name, properties) {
+    this.send({
+      type: 'track',
+      name,
+      properties
+    });
+  }
+  /**
+   * Core send path: if at least one integration is ready -> deliver immediately
+   * Else enqueue (bounded FIFO)
+   */
+  send(partial) {
+    const envelope = {
+      id: uuid(),
+      type: partial.type,
+      timestamp: Date.now(),
+      name: partial.name,
+      properties: partial.properties,
+      context: Object.assign({}, this.context)
+    };
+    // If we're not ready, enqueue
+    if (!this.isReady()) {
+      if (this.globalQueue.length >= this.config.maxQueueSize) {
+        // drop oldest
+        this.globalQueue.shift();
+        this.logger.warn('queue full → dropped oldest');
+      }
+      this.globalQueue.push(envelope);
+      this.logger.log(`queued (${this.globalQueue.length})`, envelope);
+      return;
+    }
+    this.deliver(envelope);
+  }
+  deliver(evt) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+      for (const {
+        integration,
+        status
+      } of this.integrations.values()) {
+        if (status !== 'ready') continue;
+        try {
+          if (evt.type === 'track' && integration.track && evt.name) {
+            yield integration.track(evt.name, evt.properties, evt.context);
+          } else if (evt.type === 'identify' && integration.identify) {
+            yield integration.identify(evt.context.distinctId, evt.properties, evt.context);
+          }
+        } catch (e) {
+          this.logger.error(`deliver error in ${integration.name} (${evt.type})`, e);
+        }
+      }
+    });
+  }
+  /**
+   * Flush queued events FIFO once at least one integration is ready.
+   */
+  flush() {
+    // nothing to flush
+    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`);
+    const toSend = this.globalQueue;
+    this.globalQueue = [];
+    // deliver all events
+    toSend.forEach(evt => this.deliver(evt));
+  }
+  readyCount() {
+    let n = 0;
+    for (const s of this.integrations.values()) if (s.status === 'ready') n++;
+    return n;
+  }
+  isReady() {
+    // 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;
+    return true;
+  }
+  /**
+   * Setup periodic flushing if enabled
+   */
+  setupPeriodicFlushing() {
+    if (this.config.flushInterval <= 0) return;
+    this.flushTimer = setInterval(() => {
+      if (this.globalQueue.length > 0) {
+        this.logger.log('periodic flush triggered');
+        this.flush();
+      }
+    }, this.config.flushInterval);
+    this.logger.log(`periodic flushing enabled: ${this.config.flushInterval}ms`);
+  }
+  /**
+   * Setup page unload handler for client environment
+   */
+  setupUnloadHandler() {
+    if (this.currentEnvironment !== 'client' || typeof window === 'undefined') {
+      return;
+    }
+    this.unloadHandler = () => {
+      this.logger.log('page unloading, flushing remaining events');
+      this.flush();
+    };
+    // Use both beforeunload and pagehide for better coverage
+    window.addEventListener('beforeunload', this.unloadHandler);
+    window.addEventListener('pagehide', this.unloadHandler);
+    this.logger.log('page unload handlers registered');
+  }
+  /** Debug helpers */
+  getStats() {
+    return {
+      currentEnvironment: this.currentEnvironment,
+      integrations: [...this.integrations.values()].map(s => ({
+        name: s.integration.name,
+        status: s.status,
+        environments: s.integration.environments
+      })),
+      queueLength: this.globalQueue.length,
+      readyCount: this.readyCount(),
+      periodicFlushEnabled: this.config.flushInterval > 0,
+      flushInterval: this.config.flushInterval
+    };
+  }
+}
+
 const isBrowser = typeof window !== 'undefined';
 const isServer = !isBrowser;
 const PREF = 'saasco-sdk';
@@ -688,8 +1228,9 @@ function setSessionId({
 } = {
   reset: false
 }) {
-  const sessionId = reset ? uuid.v4() : getSessionId() || uuid.v4();
+  const sessionId = reset ? uuid() : getSessionId() || uuid();
   storeData(`session-id`, sessionId, SESSION_DURATION);
+  return sessionId;
 }
 function getAnonymousId() {
   return retrieveData(`anonymous-id`);
@@ -699,7 +1240,7 @@ function setAnonymousId({
 } = {
   reset: false
 }) {
-  const anonymousId = reset ? uuid.v4() : getAnonymousId() || uuid.v4();
+  const anonymousId = reset ? uuid() : getAnonymousId() || uuid();
   storeData(`anonymous-id`, anonymousId, USER_DURATION);
   return anonymousId;
 }
@@ -746,13 +1287,19 @@ class Saasco {
    * @param config.debug Whether to log debug information. Default is false.
    * @param config.trackUrlParams Whether to track URL parameters. Default is true.
    * @param config.trackHashChanges Whether to track hash changes. Default is true.
+   * @param config.integrations Configuration for third-party integrations like Facebook Pixel.
    */
   constructor(config) {
     this.config = config;
     this.lastPageViewPath = '';
     this.isInitialized = false;
+    // Initialize logger
+    this.logger = new AnalyticsLogger({
+      debug: !!this.config.debug,
+      label: 'Saasco Debug'
+    });
     if (!config.projectId) {
-      this.error("Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly.");
+      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;
     }
     // default enabled to true
@@ -763,10 +1310,17 @@ class Saasco {
       trackQueryParams: true,
       trackHash: true
     }, this.config.autoPageTracking);
+    // Initialize integration manager
+    this.integrationManager = new IntegrationManager({
+      debug: this.config.debug,
+      maxQueueSize: 1000
+    });
+    // Set initial context
+    this.integrationManager.setContext({});
   }
   init() {
     if (this.isInitialized) {
-      this.log('Saasco is already initialized. Please check your code to ensure that init() is not being called multiple times.');
+      this.logger.log('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
@@ -775,23 +1329,46 @@ class Saasco {
     }
     // Migrate existing localStorage data to cookies for cross-subdomain support
     migrateFromLocalStorage();
-    this.log('Saasco initialized', this.config);
-    if (this.config.debug) this.log('Debug mode active. This will log all events to the console.');
-    if (!this.config.enabled) this.log('Analytics is disabled. No requests will be sent to the server.');
+    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.');
+    // Initialize integrations asynchronously
+    this.initIntegrations().catch(error => {
+      this.logger.log('Error initializing integrations:', error);
+    });
     this.initAutoPageTracking();
     this.isInitialized = true;
   }
   disableDebug() {
-    this.log('Debug mode deactivated.');
+    this.logger.log('Debug mode deactivated.');
     this.config.debug = false;
   }
   enableDebug() {
     this.config.debug = true;
-    this.log('Debug mode activated.');
+    this.logger.log('Debug mode activated.');
+  }
+  /**
+   * Initialize third-party integrations
+   */
+  initIntegrations() {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+      if (!this.config.integrations || this.config.integrations.length === 0) 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);
+            yield this.integrationManager.registerIntegration(fbIntegration);
+          }
+        } catch (error) {
+          this.logger.log(`Failed to register ${integrationConfig.type} integration:`, error);
+        }
+      }
+    });
   }
   track(actionOrPayload, propertiesOrNothing, contextOrNothing) {
     if (!this.config.projectId) {
-      const response = this.error("Unable to track event. Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly.");
+      const response = this.logger.error("Unable to track event. Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly.");
       return Promise.resolve(response);
     }
     setSessionId();
@@ -800,12 +1377,12 @@ class Saasco {
     const hasPayload = typeof actionOrPayload === 'object';
     // Must do payload on the server
     if (isServer && hasAction) {
-      const response = this.error('When calling track from the server you must pass a payload object with a userId in order to track events. For example: track({ event: "Song Played", userId: "user_123", properties: { song: "Song Name" } })');
+      const response = this.logger.error('When calling track from the server you must pass a payload object with a userId in order to track events. For example: track({ event: "Song Played", userId: "user_123", properties: { song: "Song Name" } })');
       return Promise.resolve(response);
     }
     // On server events we require a userId or an anonymousId
     if (isServer && hasPayload && !actionOrPayload.userId && !actionOrPayload.anonymousId) {
-      const response = this.error('When calling track from the server you must pass a payload object with either a userId or an anonymousId in order to track events. For example:\n\ntrack({ event: "Song Played", userId: "user_123", properties: { song: "Song Name" } }). \n\nIf providing an anonymousId this must be provided from the client side otherwise we will not have a user to connect the event to.');
+      const response = this.logger.error('When calling track from the server you must pass a payload object with either a userId or an anonymousId in order to track events. For example:\n\ntrack({ event: "Song Played", userId: "user_123", properties: { song: "Song Name" } }). \n\nIf providing an anonymousId this must be provided from the client side otherwise we will not have a user to connect the event to.');
       return Promise.resolve(response);
     }
     const action = hasAction ? actionOrPayload : actionOrPayload.event;
@@ -825,7 +1402,7 @@ class Saasco {
       properties: properties || {}
     });
     const data = {
-      id: uuid.v4(),
+      id: uuid(),
       timestamp: new Date().toISOString(),
       action,
       version,
@@ -837,6 +1414,9 @@ class Saasco {
       source: isBrowser ? 'client' : 'server',
       context: JSON.stringify(context || {})
     };
+    // Send event to integrations
+    this.integrationManager.track(action, properties);
+    // Send event to API
     return this.doRequest('events', data);
   }
   /**
@@ -868,20 +1448,20 @@ class Saasco {
   }
   identify(distinctIdOrProperties, propertiesOrContext, contextOrNothing) {
     if (!this.config.projectId) {
-      const response = this.error("Unable to identify user. Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly.");
+      const response = this.logger.error("Unable to identify user. Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly.");
       return Promise.resolve(response);
     }
     const hasId = typeof distinctIdOrProperties === 'string' || typeof distinctIdOrProperties === 'number' || distinctIdOrProperties === null;
-    const distinctId = hasId ? distinctIdOrProperties === null || distinctIdOrProperties === void 0 ? void 0 : distinctIdOrProperties.toString() : `soft_${uuid.v4()}`;
+    const distinctId = hasId ? distinctIdOrProperties === null || distinctIdOrProperties === void 0 ? void 0 : distinctIdOrProperties.toString() : `soft_${uuid()}`;
     const properties = hasId ? propertiesOrContext : distinctIdOrProperties;
     const context = hasId ? contextOrNothing : propertiesOrContext;
     // When the user gets identified as null this will reset the users session and anonymous id
     // 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.log('User logged out');
+    if (userIdChangedToNull) this.logger.log('User logged out');
     const reset = userIdChangedToNull;
-    setSessionId({
+    const sessionId = setSessionId({
       reset
     });
     const anonymousId = setAnonymousId({
@@ -889,13 +1469,21 @@ 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({
+      distinctId,
+      anonymousId,
+      sessionId
+    });
+    this.integrationManager.identify(distinctId, properties);
     // No distinctId provided so we don't track the user
     if (!distinctId) return Promise.resolve({
       success: true,
       message: 'No distinctId provided'
     });
+    // Send identify to API
     const data = {
-      id: uuid.v4(),
+      id: uuid(),
       timestamp: new Date().toISOString(),
       projectId: this.config.projectId,
       distinctId,
@@ -929,9 +1517,9 @@ class Saasco {
       const base = this.config.proxy || 'https://www.saasco.com/api/';
       const url = `${base}${path}`;
       if (data.action === 'Page View') {
-        this.log('Page View', window.location.href, data);
+        this.logger.log('Page View', window.location.href, data);
       } else {
-        this.log(data.action || path, data);
+        this.logger.log(data.action || path, data);
       }
       // If analytics is disabled, don't send the request
       if (this.config.enabled === false) return {
@@ -955,7 +1543,7 @@ class Saasco {
           message: responseBody.message
         };
       } catch (error) {
-        this.error(`\nError Message: "${error.message}"`, `\nPath: "/${path}"`, `\nRequest Data: ${JSON.stringify(data, null, 2)}`);
+        this.logger.error(`\nError Message: "${error.message}"`, `\nPath: "/${path}"`, `\nRequest Data: ${JSON.stringify(data, null, 2)}`);
         return {
           success: false,
           message: error.message
@@ -963,29 +1551,6 @@ class Saasco {
       }
     });
   }
-  /**
-   * @param args Arguments to be logged
-   */
-  log(...args) {
-    if (!this.config.debug) return;
-    const message = '◍ Saasco Debug';
-    console.info(
-    // Message highlighted for easy finding
-    `%c ${message}`, 'background: #eee; color: #000; padding: 2px 4px; border-radius: 2px;', ...args);
-  }
-  /**
-   * @param args Arguments to be logged
-   */
-  error(...args) {
-    const message = '◍ Saasco Error';
-    console.error(
-    // Message highlighted for easy finding
-    `%c ${message}`, 'background: red; color: white; padding: 2px 4px; border-radius: 2px;', ...args);
-    return {
-      success: false,
-      message: args.join(' ')
-    };
-  }
   /**
    * If autoPageTracking is enabled, this will automatically track page views
    * It listens to url changes to track new pages every time the url changes
@@ -999,11 +1564,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.log('Auto Page Tracking already enabled');
+      this.logger.log('Auto Page Tracking already enabled');
       return;
     }
     window.saascoAutoPageTrackingActive = true;
-    this.log('Auto Page Tracking enabled');
+    this.logger.log('Auto Page Tracking enabled');
     // Track initial page load
     this.page();
     // Listen for hash changes if hash tracking is enabled
@@ -1054,7 +1619,12 @@ const browserContextSchema = zod.z.object({
   $utmAdId: zod.z.string().nullable()
 });
 
+exports.IntegrationManager = IntegrationManager;
+exports.Logger = Logger;
 exports.Saasco = Saasco;
 exports.browserContextSchema = browserContextSchema;
+exports.createFacebookPixelIntegration = createFacebookPixelIntegration;
 exports.getBrowserContext = getBrowserContext;
+exports.initializeFacebookPixel = initializeFacebookPixel;
 exports.timezones = timezones;
+exports.trackFacebookEvent = trackFacebookEvent;