@happyvertical/analytics 0.74.8

package/dist/chunks/ga4-6gyDPZRn.js

@@ -0,0 +1,863 @@
+import { readFile } from "node:fs/promises";
+import { google } from "googleapis";
+import { AuthenticationError, AnalyticsError, QuotaExceededError, RateLimitError, PropertyNotFoundError } from "../index.js";
+const MEASUREMENT_PROTOCOL_URL = "https://www.google-analytics.com/mp/collect";
+const PROPERTY_HYDRATION_CONCURRENCY = 5;
+class GA4Provider {
+  adminClient = null;
+  dataClient = null;
+  options;
+  credentials = null;
+  constructor(options) {
+    this.options = {
+      timeout: 3e4,
+      maxRetries: 3,
+      cacheTTL: 36e5,
+      // 1 hour
+      ...options
+    };
+  }
+  /**
+   * Initialize Google API clients with service account credentials
+   */
+  async ensureClients() {
+    if (this.adminClient && this.dataClient) {
+      return;
+    }
+    if (!this.credentials && this.options.serviceAccountKey) {
+      if (typeof this.options.serviceAccountKey === "string") {
+        const content = await readFile(this.options.serviceAccountKey, "utf-8");
+        this.credentials = JSON.parse(content);
+      } else {
+        this.credentials = this.options.serviceAccountKey;
+      }
+    }
+    if (!this.credentials) {
+      throw new AuthenticationError("ga4");
+    }
+    const auth = new google.auth.GoogleAuth({
+      credentials: this.credentials,
+      scopes: [
+        "https://www.googleapis.com/auth/analytics.readonly",
+        "https://www.googleapis.com/auth/analytics.edit"
+      ]
+    });
+    this.adminClient = google.analyticsadmin({
+      version: "v1beta",
+      auth
+    });
+    this.dataClient = google.analyticsdata({
+      version: "v1beta",
+      auth
+    });
+  }
+  /**
+   * Normalize property ID to numeric format
+   */
+  normalizePropertyId(propertyId) {
+    return propertyId.replace(/^properties\//, "");
+  }
+  /**
+   * Get full property resource name
+   */
+  getPropertyName(propertyId) {
+    const id = this.normalizePropertyId(propertyId);
+    return `properties/${id}`;
+  }
+  /**
+   * Map a Google Analytics property resource to the public Property shape
+   */
+  mapProperty(property) {
+    return {
+      id: property.name?.replace("properties/", "") || "",
+      name: property.name || "",
+      displayName: property.displayName || "",
+      createTime: property.createTime || "",
+      updateTime: property.updateTime ?? void 0,
+      timeZone: property.timeZone ?? void 0,
+      currencyCode: property.currencyCode ?? void 0,
+      industryCategory: property.industryCategory ?? void 0,
+      serviceLevel: property.serviceLevel
+    };
+  }
+  /**
+   * Hydrate discovered properties without firing unbounded concurrent requests
+   */
+  async hydrateProperties(properties) {
+    const hydrated = [];
+    for (let index = 0; index < properties.length; index += PROPERTY_HYDRATION_CONCURRENCY) {
+      const batch = properties.slice(
+        index,
+        index + PROPERTY_HYDRATION_CONCURRENCY
+      );
+      const hydratedBatch = await Promise.all(
+        batch.map(async (property) => {
+          const response = await this.adminClient.properties.get({
+            name: property.name
+          });
+          return this.mapProperty(response.data);
+        })
+      );
+      hydrated.push(...hydratedBatch);
+    }
+    return hydrated;
+  }
+  /**
+   * Map Google API errors to our error types
+   */
+  mapError(error) {
+    if (error instanceof AnalyticsError) {
+      return error;
+    }
+    const err = error;
+    const status = err.code || err.status;
+    const message = err.message || "Unknown error";
+    switch (status) {
+      case 401:
+      case 403:
+        return new AuthenticationError("ga4");
+      case 404:
+        return new PropertyNotFoundError(message, "ga4");
+      case 429:
+        return new RateLimitError("ga4");
+      case 402:
+        return new QuotaExceededError("ga4");
+      default:
+        return new AnalyticsError(message, "API_ERROR", "ga4");
+    }
+  }
+  // ===========================================================================
+  // Property Management
+  // ===========================================================================
+  async createProperty(options) {
+    await this.ensureClients();
+    if (!options.parent) {
+      throw new AnalyticsError(
+        "Parent account is required for creating GA4 properties",
+        "MISSING_PARENT",
+        "ga4"
+      );
+    }
+    try {
+      const response = await this.adminClient.properties.create({
+        requestBody: {
+          displayName: options.displayName,
+          timeZone: options.timeZone || "America/Los_Angeles",
+          currencyCode: options.currencyCode || "USD",
+          industryCategory: options.industryCategory,
+          parent: options.parent
+        }
+      });
+      const property = this.mapProperty(response.data);
+      if (!property.createTime) {
+        property.createTime = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return property;
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async listProperties(options) {
+    await this.ensureClients();
+    try {
+      const properties = /* @__PURE__ */ new Map();
+      let pageToken;
+      do {
+        const response = await this.adminClient.accountSummaries.list({
+          pageSize: 200,
+          pageToken
+        });
+        for (const accountSummary of response.data.accountSummaries || []) {
+          for (const propertySummary of accountSummary.propertySummaries || []) {
+            const propertyName = propertySummary.property || "";
+            if (!propertyName || properties.has(propertyName)) {
+              continue;
+            }
+            properties.set(propertyName, {
+              id: propertyName.replace("properties/", ""),
+              name: propertyName,
+              displayName: propertySummary.displayName || "",
+              createTime: ""
+            });
+          }
+        }
+        pageToken = response.data.nextPageToken ?? void 0;
+      } while (pageToken);
+      const listedProperties = [...properties.values()];
+      if (options?.hydrate === false) {
+        return listedProperties;
+      }
+      return this.hydrateProperties(listedProperties);
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async getProperty(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.get({
+        name: this.getPropertyName(propertyId)
+      });
+      return this.mapProperty(response.data);
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async updateProperty(propertyId, data) {
+    await this.ensureClients();
+    const updateMask = [];
+    if (data.displayName) updateMask.push("displayName");
+    if (data.timeZone) updateMask.push("timeZone");
+    if (data.currencyCode) updateMask.push("currencyCode");
+    if (data.industryCategory) updateMask.push("industryCategory");
+    try {
+      const response = await this.adminClient.properties.patch({
+        name: this.getPropertyName(propertyId),
+        updateMask: updateMask.join(","),
+        requestBody: {
+          displayName: data.displayName,
+          timeZone: data.timeZone,
+          currencyCode: data.currencyCode,
+          industryCategory: data.industryCategory
+        }
+      });
+      return this.mapProperty(response.data);
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async deleteProperty(propertyId) {
+    await this.ensureClients();
+    try {
+      await this.adminClient.properties.delete({
+        name: this.getPropertyName(propertyId)
+      });
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  // ===========================================================================
+  // Data Streams
+  // ===========================================================================
+  async getDataStreams(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.dataStreams.list({
+        parent: this.getPropertyName(propertyId)
+      });
+      return (response.data.dataStreams || []).map(
+        (ds) => ({
+          id: ds.name?.split("/").pop() || "",
+          type: ds.type,
+          displayName: ds.displayName || "",
+          measurementId: ds.webStreamData?.measurementId ?? void 0,
+          firebaseAppId: ds.androidAppStreamData?.firebaseAppId ?? ds.iosAppStreamData?.firebaseAppId ?? void 0,
+          defaultUri: ds.webStreamData?.defaultUri ?? void 0,
+          createTime: ds.createTime || "",
+          updateTime: ds.updateTime ?? void 0
+        })
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async createDataStream(propertyId, options) {
+    await this.ensureClients();
+    try {
+      const requestBody = {
+        type: options.type,
+        displayName: options.displayName
+      };
+      if (options.type === "WEB_DATA_STREAM") {
+        requestBody.webStreamData = {
+          defaultUri: options.defaultUri
+        };
+      } else if (options.type === "ANDROID_APP_DATA_STREAM") {
+        requestBody.androidAppStreamData = {
+          packageName: options.packageName
+        };
+      } else if (options.type === "IOS_APP_DATA_STREAM") {
+        requestBody.iosAppStreamData = {
+          bundleId: options.bundleId
+        };
+      }
+      const response = await this.adminClient.properties.dataStreams.create({
+        parent: this.getPropertyName(propertyId),
+        requestBody
+      });
+      const ds = response.data;
+      return {
+        id: ds.name?.split("/").pop() || "",
+        type: ds.type,
+        displayName: ds.displayName || "",
+        measurementId: ds.webStreamData?.measurementId ?? void 0,
+        firebaseAppId: ds.androidAppStreamData?.firebaseAppId ?? ds.iosAppStreamData?.firebaseAppId ?? void 0,
+        defaultUri: ds.webStreamData?.defaultUri ?? void 0,
+        createTime: ds.createTime || "",
+        updateTime: ds.updateTime ?? void 0
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async deleteDataStream(propertyId, streamId) {
+    await this.ensureClients();
+    try {
+      await this.adminClient.properties.dataStreams.delete({
+        name: `${this.getPropertyName(propertyId)}/dataStreams/${streamId}`
+      });
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  // ===========================================================================
+  // Custom Definitions
+  // ===========================================================================
+  async getCustomDimensions(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.customDimensions.list(
+        {
+          parent: this.getPropertyName(propertyId)
+        }
+      );
+      return (response.data.customDimensions || []).map(
+        (cd) => ({
+          id: cd.name?.split("/").pop() || "",
+          name: cd.name || "",
+          parameterName: cd.parameterName || "",
+          displayName: cd.displayName || "",
+          description: cd.description ?? void 0,
+          scope: cd.scope,
+          disallowAdsPersonalization: cd.disallowAdsPersonalization ?? void 0
+        })
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async createCustomDimension(propertyId, options) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.customDimensions.create({
+        parent: this.getPropertyName(propertyId),
+        requestBody: {
+          parameterName: options.parameterName,
+          displayName: options.displayName,
+          description: options.description,
+          scope: options.scope,
+          disallowAdsPersonalization: options.disallowAdsPersonalization
+        }
+      });
+      const cd = response.data;
+      return {
+        id: cd.name?.split("/").pop() || "",
+        name: cd.name || "",
+        parameterName: cd.parameterName || "",
+        displayName: cd.displayName || "",
+        description: cd.description ?? void 0,
+        scope: cd.scope,
+        disallowAdsPersonalization: cd.disallowAdsPersonalization ?? void 0
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async archiveCustomDimension(propertyId, dimensionId) {
+    await this.ensureClients();
+    try {
+      await this.adminClient.properties.customDimensions.archive({
+        name: `${this.getPropertyName(propertyId)}/customDimensions/${dimensionId}`
+      });
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async getCustomMetrics(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.customMetrics.list({
+        parent: this.getPropertyName(propertyId)
+      });
+      return (response.data.customMetrics || []).map(
+        (cm) => ({
+          id: cm.name?.split("/").pop() || "",
+          name: cm.name || "",
+          parameterName: cm.parameterName || "",
+          displayName: cm.displayName || "",
+          description: cm.description ?? void 0,
+          scope: "EVENT",
+          measurementUnit: cm.measurementUnit,
+          restrictedMetricType: cm.restrictedMetricType?.[0] ?? void 0
+        })
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async createCustomMetric(propertyId, options) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.customMetrics.create({
+        parent: this.getPropertyName(propertyId),
+        requestBody: {
+          parameterName: options.parameterName,
+          displayName: options.displayName,
+          description: options.description,
+          measurementUnit: options.measurementUnit,
+          restrictedMetricType: options.restrictedMetricType ? [options.restrictedMetricType] : void 0,
+          scope: "EVENT"
+        }
+      });
+      const cm = response.data;
+      return {
+        id: cm.name?.split("/").pop() || "",
+        name: cm.name || "",
+        parameterName: cm.parameterName || "",
+        displayName: cm.displayName || "",
+        description: cm.description ?? void 0,
+        scope: "EVENT",
+        measurementUnit: cm.measurementUnit,
+        restrictedMetricType: cm.restrictedMetricType?.[0] ?? void 0
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async archiveCustomMetric(propertyId, metricId) {
+    await this.ensureClients();
+    try {
+      await this.adminClient.properties.customMetrics.archive({
+        name: `${this.getPropertyName(propertyId)}/customMetrics/${metricId}`
+      });
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  // ===========================================================================
+  // Key Events (Conversions)
+  // ===========================================================================
+  async getKeyEvents(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.keyEvents.list({
+        parent: this.getPropertyName(propertyId)
+      });
+      return (response.data.keyEvents || []).map(
+        (ke) => ({
+          id: ke.name?.split("/").pop() || "",
+          name: ke.name || "",
+          eventName: ke.eventName || "",
+          createTime: ke.createTime || "",
+          countingMethod: ke.countingMethod,
+          defaultValue: ke.defaultValue ? {
+            numericValue: ke.defaultValue.numericValue ?? void 0,
+            currencyCode: ke.defaultValue.currencyCode ?? void 0
+          } : void 0
+        })
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async createKeyEvent(propertyId, options) {
+    await this.ensureClients();
+    try {
+      const response = await this.adminClient.properties.keyEvents.create({
+        parent: this.getPropertyName(propertyId),
+        requestBody: {
+          eventName: options.eventName,
+          countingMethod: options.countingMethod,
+          defaultValue: options.defaultValue
+        }
+      });
+      const ke = response.data;
+      return {
+        id: ke.name?.split("/").pop() || "",
+        name: ke.name || "",
+        eventName: ke.eventName || "",
+        createTime: ke.createTime || "",
+        countingMethod: ke.countingMethod,
+        defaultValue: ke.defaultValue ? {
+          numericValue: ke.defaultValue.numericValue ?? void 0,
+          currencyCode: ke.defaultValue.currencyCode ?? void 0
+        } : void 0
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async deleteKeyEvent(propertyId, eventId) {
+    await this.ensureClients();
+    try {
+      await this.adminClient.properties.keyEvents.delete({
+        name: `${this.getPropertyName(propertyId)}/keyEvents/${eventId}`
+      });
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  // ===========================================================================
+  // Reporting
+  // ===========================================================================
+  async runReport(propertyId, options) {
+    await this.ensureClients();
+    try {
+      const response = await this.dataClient.properties.runReport({
+        property: this.getPropertyName(propertyId),
+        requestBody: {
+          dateRanges: options.dateRanges,
+          dimensions: options.dimensions,
+          metrics: options.metrics,
+          dimensionFilter: options.dimensionFilter,
+          metricFilter: options.metricFilter,
+          offset: options.offset ? String(options.offset) : void 0,
+          limit: options.limit ? String(options.limit) : void 0,
+          orderBys: options.orderBys,
+          keepEmptyRows: options.keepEmptyRows,
+          returnPropertyQuota: options.returnPropertyQuota
+        }
+      });
+      const data = response.data;
+      return {
+        dimensionHeaders: (data.dimensionHeaders || []).map(
+          (h) => ({
+            name: h.name || ""
+          })
+        ),
+        metricHeaders: (data.metricHeaders || []).map(
+          (h) => ({
+            name: h.name || "",
+            type: h.type || ""
+          })
+        ),
+        rows: (data.rows || []).map((r) => ({
+          dimensionValues: (r.dimensionValues || []).map(
+            (v) => ({
+              value: v.value || ""
+            })
+          ),
+          metricValues: (r.metricValues || []).map(
+            (v) => ({
+              value: v.value || ""
+            })
+          )
+        })),
+        rowCount: data.rowCount ?? void 0,
+        metadata: data.metadata ? {
+          currencyCode: data.metadata.currencyCode ?? void 0,
+          timeZone: data.metadata.timeZone ?? void 0,
+          dataLossFromOtherRow: data.metadata.dataLossFromOtherRow ?? void 0,
+          emptyReason: data.metadata.emptyReason ?? void 0
+        } : void 0,
+        propertyQuota: data.propertyQuota ? {
+          tokensPerDay: {
+            consumed: data.propertyQuota.tokensPerDay?.consumed || 0,
+            remaining: data.propertyQuota.tokensPerDay?.remaining || 0
+          },
+          tokensPerHour: {
+            consumed: data.propertyQuota.tokensPerHour?.consumed || 0,
+            remaining: data.propertyQuota.tokensPerHour?.remaining || 0
+          },
+          concurrentRequests: {
+            consumed: data.propertyQuota.concurrentRequests?.consumed || 0,
+            remaining: data.propertyQuota.concurrentRequests?.remaining || 0
+          }
+        } : void 0
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async runRealtimeReport(propertyId, options) {
+    await this.ensureClients();
+    try {
+      const response = await this.dataClient.properties.runRealtimeReport({
+        property: this.getPropertyName(propertyId),
+        requestBody: {
+          dimensions: options?.dimensions,
+          metrics: options?.metrics || [{ name: "activeUsers" }],
+          dimensionFilter: options?.dimensionFilter,
+          metricFilter: options?.metricFilter,
+          limit: options?.limit ? String(options.limit) : void 0,
+          minuteRanges: options?.minuteRanges
+        }
+      });
+      const data = response.data;
+      return {
+        dimensionHeaders: (data.dimensionHeaders || []).map(
+          (h) => ({
+            name: h.name || ""
+          })
+        ),
+        metricHeaders: (data.metricHeaders || []).map(
+          (h) => ({
+            name: h.name || "",
+            type: h.type || ""
+          })
+        ),
+        rows: (data.rows || []).map((r) => ({
+          dimensionValues: (r.dimensionValues || []).map(
+            (v) => ({
+              value: v.value || ""
+            })
+          ),
+          metricValues: (r.metricValues || []).map(
+            (v) => ({
+              value: v.value || ""
+            })
+          )
+        })),
+        rowCount: data.rowCount ?? void 0
+      };
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async getMetrics(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.dataClient.properties.getMetadata({
+        name: `${this.getPropertyName(propertyId)}/metadata`
+      });
+      return (response.data.metrics || []).map(
+        (m) => ({
+          apiName: m.apiName || "",
+          uiName: m.uiName || "",
+          description: m.description || "",
+          deprecatedApiNames: m.deprecatedApiNames ?? void 0,
+          type: m.type,
+          expression: m.expression ?? void 0,
+          customDefinition: m.customDefinition ?? void 0,
+          blockedReasons: m.blockedReasons ?? void 0,
+          category: m.category ?? void 0
+        })
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  async getDimensions(propertyId) {
+    await this.ensureClients();
+    try {
+      const response = await this.dataClient.properties.getMetadata({
+        name: `${this.getPropertyName(propertyId)}/metadata`
+      });
+      return (response.data.dimensions || []).map(
+        (d) => ({
+          apiName: d.apiName || "",
+          uiName: d.uiName || "",
+          description: d.description || "",
+          deprecatedApiNames: d.deprecatedApiNames ?? void 0,
+          customDefinition: d.customDefinition ?? void 0,
+          category: d.category ?? void 0
+        })
+      );
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  // ===========================================================================
+  // Event Tracking (Measurement Protocol)
+  // ===========================================================================
+  async track(event) {
+    if (!this.options.measurementId || !this.options.apiSecret) {
+      throw new AnalyticsError(
+        "Measurement ID and API Secret are required for server-side tracking",
+        "MISSING_CREDENTIALS",
+        "ga4"
+      );
+    }
+    const clientId = event.clientId || this.generateClientId();
+    const url = `${MEASUREMENT_PROTOCOL_URL}?measurement_id=${this.options.measurementId}&api_secret=${this.options.apiSecret}`;
+    const payload = {
+      client_id: clientId,
+      user_id: event.userId,
+      timestamp_micros: event.timestamp,
+      non_personalized_ads: event.nonPersonalizedAds,
+      events: [
+        {
+          name: event.name,
+          params: event.params
+        }
+      ]
+    };
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new AnalyticsError(
+          `Measurement Protocol error: ${response.status}`,
+          "TRACKING_ERROR",
+          "ga4"
+        );
+      }
+    } catch (error) {
+      if (error instanceof AnalyticsError) {
+        throw error;
+      }
+      throw this.mapError(error);
+    }
+  }
+  async trackPageview(pageview) {
+    await this.track({
+      name: "page_view",
+      params: {
+        page_path: pageview.pagePath,
+        page_title: pageview.pageTitle || "",
+        page_location: pageview.pageLocation || "",
+        ...pageview.params
+      },
+      clientId: pageview.clientId,
+      userId: pageview.userId
+    });
+  }
+  async trackBatch(events) {
+    if (!this.options.measurementId || !this.options.apiSecret) {
+      throw new AnalyticsError(
+        "Measurement ID and API Secret are required for server-side tracking",
+        "MISSING_CREDENTIALS",
+        "ga4"
+      );
+    }
+    const batchSize = 25;
+    for (let i = 0; i < events.length; i += batchSize) {
+      const batch = events.slice(i, i + batchSize);
+      const byClient = /* @__PURE__ */ new Map();
+      for (const event of batch) {
+        const clientId = event.clientId || this.generateClientId();
+        const existing = byClient.get(clientId) || [];
+        existing.push(event);
+        byClient.set(clientId, existing);
+      }
+      for (const [clientId, clientEvents] of byClient) {
+        const url = `${MEASUREMENT_PROTOCOL_URL}?measurement_id=${this.options.measurementId}&api_secret=${this.options.apiSecret}`;
+        const payload = {
+          client_id: clientId,
+          events: clientEvents.map((e) => ({
+            name: e.name,
+            params: e.params
+          }))
+        };
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(payload)
+          });
+          if (!response.ok) {
+            throw new AnalyticsError(
+              `Measurement Protocol error: ${response.status}`,
+              "TRACKING_ERROR",
+              "ga4"
+            );
+          }
+        } catch (error) {
+          if (error instanceof AnalyticsError) {
+            throw error;
+          }
+          throw this.mapError(error);
+        }
+      }
+    }
+  }
+  async identify(userId, traits) {
+    await this.track({
+      name: "user_engagement",
+      userId,
+      params: traits
+    });
+  }
+  /**
+   * Generate a random client ID for Measurement Protocol
+   */
+  generateClientId() {
+    return `${Math.floor(Math.random() * 2147483647)}.${Math.floor(Date.now() / 1e3)}`;
+  }
+  // ===========================================================================
+  // Client-Side Helpers
+  // ===========================================================================
+  generateTrackingSnippet(propertyId, options) {
+    const measurementId = this.options.measurementId || `G-${propertyId}`;
+    const configOptions = {};
+    if (options?.anonymizeIp) {
+      configOptions.anonymize_ip = true;
+    }
+    if (options?.sendPageView === false) {
+      configOptions.send_page_view = false;
+    }
+    if (options?.cookieFlags) {
+      configOptions.cookie_flags = options.cookieFlags;
+    }
+    if (options?.customConfig) {
+      Object.assign(configOptions, options.customConfig);
+    }
+    const configStr = Object.keys(configOptions).length > 0 ? `, ${JSON.stringify(configOptions)}` : "";
+    const html = `<!-- Google Analytics -->
+<script async src="https://www.googletagmanager.com/gtag/js?id=${measurementId}"><\/script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', '${measurementId}'${configStr});
+<\/script>`;
+    return {
+      html,
+      config: {
+        measurementId,
+        ...configOptions
+      },
+      scripts: [`https://www.googletagmanager.com/gtag/js?id=${measurementId}`]
+    };
+  }
+  generateConfig(propertyId, options) {
+    const measurementId = this.options.measurementId || `G-${propertyId}`;
+    const config = {
+      measurement_id: measurementId
+    };
+    if (options?.anonymizeIp) {
+      config.anonymize_ip = true;
+    }
+    if (options?.sendPageView === false) {
+      config.send_page_view = false;
+    }
+    if (options?.userId) {
+      config.user_id = options.userId;
+    }
+    if (options?.customDimensions) {
+      Object.entries(options.customDimensions).forEach(([key, value]) => {
+        config[key] = value;
+      });
+    }
+    return config;
+  }
+  // ===========================================================================
+  // Provider Info
+  // ===========================================================================
+  async getCapabilities() {
+    return {
+      propertyManagement: true,
+      dataStreams: true,
+      customDimensions: true,
+      customMetrics: true,
+      keyEvents: true,
+      reporting: true,
+      realtimeReporting: true,
+      serverSideTracking: true,
+      clientSideSnippet: true,
+      userIdentification: true,
+      batchTracking: true
+    };
+  }
+}
+export {
+  GA4Provider
+};
+//# sourceMappingURL=ga4-6gyDPZRn.js.map