saasco-sdk 0.1.31 → 0.1.32

package/index.esm.js

@@ -1,9 +1,9 @@
 import { __awaiter } from 'tslib';
-import { v4 } from '@lukeed/uuid';
 import { isValid, parse } from 'psl';
+import { v4 } from '@lukeed/uuid';
 import { z } from 'zod';
 
-var version = "0.1.31";
+var version = "0.1.32";
 
 const timezones = {
   'Asia/Barnaul': 'RU',
@@ -550,6 +550,385 @@ 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: () => __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, fbParams);
+      } else {
+        window.fbq('track', fbEventName);
+      }
+    },
+    identify: (userId, properties, context) => {
+      if (!isPixelReady || !window.fbq) return;
+      // Facebook Pixel doesn't have explicit identify method
+      // We can use advanced matching or track as CompleteRegistration
+      if (userId && properties) {
+        // Track as registration/identification event
+        window.fbq('track', 'CompleteRegistration', properties);
+      }
+    }
+  };
+}
+function getFacebookEventName(eventName, eventMapping) {
+  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);
+  }
+}
+
+/* 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;
+    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 __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) {
+    for (const {
+      integration,
+      status
+    } of this.integrations.values()) {
+      if (status !== 'ready') continue;
+      try {
+        if (evt.type === 'track' && integration.track && evt.name) {
+          integration.track(evt.name, evt.properties, evt.context);
+        } else if (evt.type === 'identify' && integration.identify) {
+          integration.identify(evt.context.distinctId, evt.properties, evt.context);
+        }
+      } catch (e) {
+        this.logger.error(`deliver error in ${integration.name}`, 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';
@@ -684,8 +1063,9 @@ function setSessionId({
 } = {
   reset: false
 }) {
-  const sessionId = reset ? v4() : getSessionId() || v4();
+  const sessionId = reset ? uuid() : getSessionId() || uuid();
   storeData(`session-id`, sessionId, SESSION_DURATION);
+  return sessionId;
 }
 function getAnonymousId() {
   return retrieveData(`anonymous-id`);
@@ -695,7 +1075,7 @@ function setAnonymousId({
 } = {
   reset: false
 }) {
-  const anonymousId = reset ? v4() : getAnonymousId() || v4();
+  const anonymousId = reset ? uuid() : getAnonymousId() || uuid();
   storeData(`anonymous-id`, anonymousId, USER_DURATION);
   return anonymousId;
 }
@@ -742,13 +1122,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
@@ -759,10 +1145,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
@@ -771,23 +1164,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 __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();
@@ -796,12 +1212,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;
@@ -821,7 +1237,7 @@ class Saasco {
       properties: properties || {}
     });
     const data = {
-      id: v4(),
+      id: uuid(),
       timestamp: new Date().toISOString(),
       action,
       version,
@@ -833,6 +1249,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);
   }
   /**
@@ -864,20 +1283,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_${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({
@@ -885,13 +1304,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: v4(),
+      id: uuid(),
       timestamp: new Date().toISOString(),
       projectId: this.config.projectId,
       distinctId,
@@ -925,9 +1352,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 {
@@ -951,7 +1378,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
@@ -959,29 +1386,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
@@ -995,11 +1399,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
@@ -1050,4 +1454,34 @@ const browserContextSchema = z.object({
   $utmAdId: z.string().nullable()
 });
 
-export { Saasco, browserContextSchema, getBrowserContext, timezones };
+/**
+ * Example integration that works on both client and server
+ * Simply logs events to console
+ */
+function createConsoleIntegration(config = {}) {
+  const prefix = config.prefix || '[Analytics]';
+  return {
+    name: 'console',
+    environments: ['client', 'server'],
+    // This integration works on both client and server
+    init: () => {
+      console.log(`${prefix} Console integration initialized`);
+    },
+    track: (eventName, properties, context) => {
+      console.log(`${prefix} Track:`, {
+        event: eventName,
+        properties,
+        context
+      });
+    },
+    identify: (userId, properties, context) => {
+      console.log(`${prefix} Identify:`, {
+        userId,
+        properties,
+        context
+      });
+    }
+  };
+}
+
+export { IntegrationManager, Logger, Saasco, browserContextSchema, createConsoleIntegration, createFacebookPixelIntegration, getBrowserContext, initializeFacebookPixel, timezones, trackFacebookEvent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saasco-sdk",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "dependencies": {
     "tslib": "^2.3.0",
     "@lukeed/uuid": "^2.0.1",