@happyvertical/analytics 0.79.0 → 0.80.1

package/AGENT.md

@@ -7,7 +7,7 @@ Unified analytics interface for Google Analytics 4, Plausible, and more
 ## Package Map
 - Package: `@happyvertical/analytics`
 - Hierarchy path: `@happyvertical/sdk > packages > analytics`
-- Workspace position: `3 of 31` local packages
+- Workspace position: `3 of 32` local packages
 - Internal dependencies: `@happyvertical/utils`
 - Internal dependents: none
 - Knowledge graph files: `AGENT.md`, `metadata.json`, `ecosystem-manifest.json`

package/dist/chunks/ga4-B69in3EQ.js

@@ -0,0 +1,668 @@
+import { c as RateLimitError, n as AuthenticationError, o as PropertyNotFoundError, s as QuotaExceededError, t as AnalyticsError } from "./types-zsbKROGX.js";
+import { readFile } from "node:fs/promises";
+import { google } from "googleapis";
+//#region src/shared/providers/ga4.ts
+/**
+* Google Analytics 4 provider implementation
+*
+* Uses three APIs internally:
+* - Admin API: Property management, data streams, custom definitions
+* - Data API: Reports and analytics queries
+* - Measurement Protocol: Server-side event tracking
+*/
+/**
+* Measurement Protocol endpoint
+*/
+var MEASUREMENT_PROTOCOL_URL = "https://www.google-analytics.com/mp/collect";
+var PROPERTY_HYDRATION_CONCURRENCY = 5;
+/**
+* Google Analytics 4 provider
+*/
+var GA4Provider = class {
+	adminClient = null;
+	dataClient = null;
+	options;
+	credentials = null;
+	constructor(options) {
+		this.options = {
+			timeout: 3e4,
+			maxRetries: 3,
+			cacheTTL: 36e5,
+			...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) {
+		return `properties/${this.normalizePropertyId(propertyId)}`;
+	}
+	/**
+	* 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");
+		}
+	}
+	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);
+		}
+	}
+	async getDataStreams(propertyId) {
+		await this.ensureClients();
+		try {
+			return ((await this.adminClient.properties.dataStreams.list({ parent: this.getPropertyName(propertyId) })).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 ds = (await this.adminClient.properties.dataStreams.create({
+				parent: this.getPropertyName(propertyId),
+				requestBody
+			})).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);
+		}
+	}
+	async getCustomDimensions(propertyId) {
+		await this.ensureClients();
+		try {
+			return ((await this.adminClient.properties.customDimensions.list({ parent: this.getPropertyName(propertyId) })).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 cd = (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
+				}
+			})).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 {
+			return ((await this.adminClient.properties.customMetrics.list({ parent: this.getPropertyName(propertyId) })).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 cm = (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"
+				}
+			})).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);
+		}
+	}
+	async getKeyEvents(propertyId) {
+		await this.ensureClients();
+		try {
+			return ((await this.adminClient.properties.keyEvents.list({ parent: this.getPropertyName(propertyId) })).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 ke = (await this.adminClient.properties.keyEvents.create({
+				parent: this.getPropertyName(propertyId),
+				requestBody: {
+					eventName: options.eventName,
+					countingMethod: options.countingMethod,
+					defaultValue: options.defaultValue
+				}
+			})).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);
+		}
+	}
+	async runReport(propertyId, options) {
+		await this.ensureClients();
+		try {
+			const data = (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
+				}
+			})).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 data = (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
+				}
+			})).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 {
+			return ((await this.dataClient.properties.getMetadata({ name: `${this.getPropertyName(propertyId)}/metadata` })).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 {
+			return ((await this.dataClient.properties.getMetadata({ name: `${this.getPropertyName(propertyId)}/metadata` })).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);
+		}
+	}
+	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)}`;
+	}
+	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);
+		return {
+			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}'${Object.keys(configOptions).length > 0 ? `, ${JSON.stringify(configOptions)}` : ""});
+<\/script>`,
+			config: {
+				measurementId,
+				...configOptions
+			},
+			scripts: [`https://www.googletagmanager.com/gtag/js?id=${measurementId}`]
+		};
+	}
+	generateConfig(propertyId, options) {
+		const config = { measurement_id: this.options.measurementId || `G-${propertyId}` };
+		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;
+	}
+	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
+		};
+	}
+};
+//#endregion
+export { GA4Provider };
+
+//# sourceMappingURL=ga4-B69in3EQ.js.map