@happyvertical/analytics 0.79.0 → 0.80.1

package/dist/chunks/matomo-CUUG_Drb.js

@@ -0,0 +1,853 @@
+import { a as NotSupportedError, n as AuthenticationError, o as PropertyNotFoundError, t as AnalyticsError } from "./types-zsbKROGX.js";
+//#region src/shared/providers/matomo-admin.ts
+/**
+* Matomo admin client.
+*
+* Implements `AnalyticsAdminInterface` against Matomo's Reporting API. Matomo
+* exposes everything we need on a single endpoint (`POST {baseUrl}/index.php`)
+* with the action selected via `module=API` + `method=...`.
+*
+* Auth is `token_auth` — passed in the POST body, never the URL, so it does
+* not appear in proxy/access logs.
+*/
+var PROVIDER$1 = "matomo";
+function stripTrailingSlash(value) {
+	return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function stripIndexPhpSuffix(value) {
+	return value.endsWith("/index.php") ? value.slice(0, -10) : value;
+}
+/**
+* Normalize a Matomo base URL: trim whitespace, strip trailing slashes, and
+* remove a trailing `/index.php` if the caller provided one. Returns the host
+* root so callers can append `/index.php` themselves.
+*/
+function normalizeMatomoBaseUrl(value) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new AnalyticsError("Matomo baseUrl is required", "MATOMO_BASE_URL_REQUIRED", PROVIDER$1);
+	return stripIndexPhpSuffix(stripTrailingSlash(trimmed));
+}
+function isJsonRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readString$1(record, key) {
+	const value = record[key];
+	if (typeof value === "string" && value.length > 0) return value;
+	if (typeof value === "number") return String(value);
+}
+function readBoolean(record, key) {
+	const value = record[key];
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		if (value === "1" || value === "true") return true;
+		if (value === "0" || value === "false") return false;
+	}
+	if (typeof value === "number") return value !== 0;
+}
+/**
+* Matomo signals errors with a JSON body of the shape
+* `{ "result": "error", "message": "..." }` and HTTP 200. Detect that.
+*/
+function readMatomoError(body) {
+	if (!isJsonRecord(body)) return void 0;
+	if (body.result !== "error") return void 0;
+	return readString$1(body, "message") ?? "Matomo returned an error";
+}
+/**
+* POST a `module=API&method=...` form to Matomo and return the parsed JSON.
+*
+* Matomo accepts `application/x-www-form-urlencoded` — we use `URLSearchParams`
+* so array values like `idSites[]=1&idSites[]=2` are handled by the runtime.
+*/
+var MatomoAdminTransport = class {
+	baseUrl;
+	tokenAuth;
+	timeout;
+	constructor(options) {
+		this.baseUrl = normalizeMatomoBaseUrl(options.baseUrl);
+		if (!options.tokenAuth) throw new AnalyticsError("Matomo tokenAuth is required", "MATOMO_TOKEN_REQUIRED", PROVIDER$1);
+		this.tokenAuth = options.tokenAuth;
+		this.timeout = options.timeout;
+	}
+	/**
+	* Call a Matomo API method by name (e.g. `SitesManager.addSite`).
+	*
+	* `params` becomes the request body. Array values are encoded as
+	* `key[]=...&key[]=...`. Undefined and null values are dropped. The
+	* reserved keys `module`, `method`, `format`, and `token_auth` are
+	* controlled by the transport — any caller-supplied value for those
+	* keys is silently ignored so they cannot override the dispatch or
+	* the response format.
+	*/
+	async call(method, params) {
+		const body = new URLSearchParams();
+		for (const [key, value] of Object.entries(params)) {
+			if (RESERVED_PARAM_KEYS.has(key)) continue;
+			if (value === void 0 || value === null) continue;
+			if (Array.isArray(value)) {
+				for (const item of value) body.append(`${key}[]`, String(item));
+				continue;
+			}
+			body.set(key, String(value));
+		}
+		body.set("module", "API");
+		body.set("method", method);
+		body.set("format", "json");
+		body.set("token_auth", this.tokenAuth);
+		const controller = typeof AbortController === "undefined" ? void 0 : new AbortController();
+		const timeoutHandle = controller && this.timeout ? setTimeout(() => controller.abort(), this.timeout) : void 0;
+		try {
+			const response = await fetch(`${this.baseUrl}/index.php`, {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/x-www-form-urlencoded"
+				},
+				body,
+				signal: controller?.signal
+			});
+			const text = await response.text();
+			if (!response.ok) throw mapHttpError(response.status, tryParseJson(text), text);
+			const parsed = text.length > 0 ? parseJsonOrThrow(text) : void 0;
+			const errorMessage = readMatomoError(parsed);
+			if (errorMessage) throw mapApplicationError(errorMessage);
+			return parsed;
+		} catch (error) {
+			if (error instanceof AnalyticsError) throw error;
+			throw new AnalyticsError(`Matomo admin request failed: ${error instanceof Error ? error.message : String(error)}`, "MATOMO_REQUEST_FAILED", PROVIDER$1);
+		} finally {
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+		}
+	}
+};
+var RESERVED_PARAM_KEYS = /* @__PURE__ */ new Set([
+	"module",
+	"method",
+	"format",
+	"token_auth"
+]);
+/**
+* Parse a 2xx response body as JSON. Matomo always answers `format=json`
+* with JSON; if it doesn't, something has gone wrong upstream (usually a
+* misconfigured reverse proxy or PHP fatal error returning HTML), and we
+* surface that as a typed error rather than silently coercing.
+*/
+function parseJsonOrThrow(text) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		const preview = text.slice(0, 200);
+		throw new AnalyticsError(`Matomo returned an invalid JSON response${error instanceof Error ? `: ${error.message}` : ""}${preview ? ` (response preview: ${preview})` : ""}`, "MATOMO_INVALID_RESPONSE", PROVIDER$1);
+	}
+}
+/**
+* Best-effort parse for non-2xx response bodies — returns `undefined` on
+* parse failure so the HTTP-error code path can still surface a useful
+* status-based message.
+*/
+function tryParseJson(text) {
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function mapHttpError(status, body, text) {
+	if (status === 401 || status === 403) return new AuthenticationError(PROVIDER$1);
+	return new AnalyticsError(isJsonRecord(body) && readString$1(body, "message") || text || `Matomo HTTP ${status}`, `MATOMO_HTTP_${status}`, PROVIDER$1);
+}
+function mapApplicationError(message) {
+	if (message.includes("requires view access") || message.includes("requires admin access") || message.includes("requires Super User access") || message.includes("doesn't have access")) return new AuthenticationError(PROVIDER$1, message, "MATOMO_ACCESS_DENIED");
+	return new AnalyticsError(message, "MATOMO_API_ERROR", PROVIDER$1);
+}
+function siteFromRow(row) {
+	const id = readString$1(row, "idsite") ?? readString$1(row, "idSite");
+	if (!id) throw new AnalyticsError("Matomo did not return a site id", "MATOMO_INVALID_RESPONSE", PROVIDER$1);
+	return {
+		id,
+		name: readString$1(row, "name") ?? "",
+		url: readString$1(row, "main_url"),
+		timezone: readString$1(row, "timezone"),
+		currency: readString$1(row, "currency"),
+		provider: PROVIDER$1,
+		raw: row
+	};
+}
+function userFromRow(row) {
+	const login = readString$1(row, "login");
+	if (!login) throw new AnalyticsError("Matomo did not return a user login", "MATOMO_INVALID_RESPONSE", PROVIDER$1);
+	return {
+		login,
+		email: readString$1(row, "email"),
+		isSuperUser: readBoolean(row, "superuser_access"),
+		provider: PROVIDER$1,
+		raw: row
+	};
+}
+var MatomoAdmin = class {
+	baseUrl;
+	timeout;
+	transport;
+	constructor(options) {
+		this.baseUrl = normalizeMatomoBaseUrl(options.baseUrl);
+		this.timeout = options.timeout;
+		this.transport = new MatomoAdminTransport({
+			...options,
+			baseUrl: this.baseUrl
+		});
+		this.createSite = this.createSite.bind(this);
+		this.listSites = this.listSites.bind(this);
+		this.getSite = this.getSite.bind(this);
+		this.updateSite = this.updateSite.bind(this);
+		this.deleteSite = this.deleteSite.bind(this);
+		this.createUser = this.createUser.bind(this);
+		this.getUser = this.getUser.bind(this);
+		this.deleteUser = this.deleteUser.bind(this);
+		this.setUserAccess = this.setUserAccess.bind(this);
+		this.verifyUserSiteAccess = this.verifyUserSiteAccess.bind(this);
+		this.verifyTokenSiteAccess = this.verifyTokenSiteAccess.bind(this);
+		this.mintUserToken = this.mintUserToken.bind(this);
+		this.health = this.health.bind(this);
+	}
+	cloneTransportWithToken(tokenAuth) {
+		return new MatomoAdminTransport({
+			baseUrl: this.baseUrl,
+			tokenAuth,
+			timeout: this.timeout
+		});
+	}
+	async createSite(options) {
+		if (!options.urls || options.urls.length === 0) throw new AnalyticsError("Matomo createSite requires at least one URL", "MATOMO_URLS_REQUIRED", PROVIDER$1);
+		const response = await this.transport.call("SitesManager.addSite", {
+			siteName: options.name,
+			urls: options.urls,
+			timezone: options.timezone,
+			currency: options.currency,
+			...options.raw ?? {}
+		});
+		const id = coerceSiteIdResponse(response);
+		if (!id) throw new AnalyticsError("Matomo did not return a site id", "MATOMO_INVALID_RESPONSE", PROVIDER$1);
+		const site = await this.getSite(id);
+		if (site) return {
+			...site,
+			tenantId: options.tenantId
+		};
+		return {
+			id,
+			name: options.name,
+			url: options.urls[0],
+			timezone: options.timezone,
+			currency: options.currency,
+			tenantId: options.tenantId,
+			provider: PROVIDER$1,
+			raw: response
+		};
+	}
+	async listSites() {
+		const response = await this.transport.call("SitesManager.getAllSites", {});
+		if (!Array.isArray(response)) return [];
+		return response.filter(isJsonRecord).map((row) => siteFromRow(row));
+	}
+	async getSite(siteId) {
+		try {
+			const response = await this.transport.call("SitesManager.getSiteFromId", { idSite: siteId });
+			if (isJsonRecord(response)) return siteFromRow(response);
+			return;
+		} catch (error) {
+			if (error instanceof AnalyticsError && isNotFoundSiteError(error)) return;
+			throw error;
+		}
+	}
+	async updateSite(options) {
+		if (options.urls && options.urls.length === 0) throw new AnalyticsError("Matomo updateSite requires at least one URL when urls is provided", "MATOMO_URLS_REQUIRED", PROVIDER$1);
+		await this.transport.call("SitesManager.updateSite", {
+			idSite: options.siteId,
+			siteName: options.name,
+			urls: options.urls,
+			timezone: options.timezone,
+			currency: options.currency,
+			...options.raw ?? {}
+		});
+		const site = await this.getSite(options.siteId);
+		if (!site) throw new AnalyticsError(`Matomo site ${options.siteId} was not found after update`, "MATOMO_SITE_NOT_FOUND", PROVIDER$1);
+		return {
+			...site,
+			tenantId: options.tenantId
+		};
+	}
+	async deleteSite(siteId) {
+		await this.transport.call("SitesManager.deleteSite", { idSite: siteId });
+	}
+	async createUser(options) {
+		if (!options.password) throw new AnalyticsError("Matomo createUser requires a password", "MATOMO_PASSWORD_REQUIRED", PROVIDER$1);
+		await this.transport.call("UsersManager.addUser", {
+			userLogin: options.login,
+			password: options.password,
+			email: options.email,
+			...options.raw ?? {}
+		});
+		return await this.getUser(options.login) ?? {
+			login: options.login,
+			email: options.email,
+			tenantId: options.tenantId,
+			provider: PROVIDER$1
+		};
+	}
+	async getUser(login) {
+		try {
+			const response = await this.transport.call("UsersManager.getUser", { userLogin: login });
+			if (isJsonRecord(response)) return userFromRow(response);
+			if (Array.isArray(response) && response.length === 0) return void 0;
+			return;
+		} catch (error) {
+			if (error instanceof AnalyticsError && error.code === "MATOMO_API_ERROR" && /doesn'?t exist|does not exist|unknown/i.test(error.message)) return;
+			throw error;
+		}
+	}
+	async deleteUser(login) {
+		await this.transport.call("UsersManager.deleteUser", { userLogin: login });
+	}
+	async setUserAccess(options) {
+		if (!isAccessRole(options.access)) throw new AnalyticsError(`Invalid Matomo access role: ${options.access}`, "MATOMO_INVALID_ROLE", PROVIDER$1);
+		if (!options.siteIds || options.siteIds.length === 0) throw new AnalyticsError("Matomo setUserAccess requires at least one site id", "MATOMO_SITE_IDS_REQUIRED", PROVIDER$1);
+		await this.transport.call("UsersManager.setUserAccess", {
+			userLogin: options.login,
+			access: options.access,
+			idSites: options.siteIds
+		});
+	}
+	async verifyUserSiteAccess(options) {
+		const requiredAccess = options.minimumAccess ?? "view";
+		if (!isAccessRole(requiredAccess)) throw new AnalyticsError(`Invalid Matomo access role: ${requiredAccess}`, "MATOMO_INVALID_ROLE", PROVIDER$1);
+		try {
+			const response = await this.transport.call("UsersManager.getSitesAccessFromUser", { userLogin: options.login });
+			let access = normalizeSiteAccessEntries(response).find((entry) => entry.siteId === options.siteId)?.access ?? "noaccess";
+			if (access === "noaccess") {
+				if ((await this.getUser(options.login))?.isSuperUser) access = "admin";
+			}
+			const ok = hasMinimumAccess(access, requiredAccess);
+			return {
+				ok,
+				provider: PROVIDER$1,
+				login: options.login,
+				siteId: options.siteId,
+				access,
+				requiredAccess,
+				errorCode: ok ? void 0 : "MATOMO_ACCESS_DENIED",
+				error: ok ? void 0 : `User "${options.login}" has ${access} access to site ${options.siteId}; ${requiredAccess} is required.`,
+				raw: response
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				provider: PROVIDER$1,
+				login: options.login,
+				siteId: options.siteId,
+				access: "noaccess",
+				requiredAccess,
+				error: error instanceof Error ? error.message : String(error),
+				errorCode: error instanceof AnalyticsError ? error.code : void 0
+			};
+		}
+	}
+	async verifyTokenSiteAccess(options) {
+		try {
+			const response = await this.cloneTransportWithToken(options.tokenAuth).call("SitesManager.getSiteFromId", { idSite: options.siteId });
+			if (Array.isArray(response) && response.length === 0) return {
+				ok: false,
+				provider: PROVIDER$1,
+				siteId: options.siteId,
+				access: "noaccess",
+				requiredAccess: "view",
+				errorCode: "MATOMO_SITE_NOT_FOUND",
+				error: `Site ${options.siteId} was not found.`,
+				raw: response
+			};
+			const siteVisible = isJsonRecord(response);
+			if (siteVisible) siteFromRow(response);
+			return {
+				ok: siteVisible,
+				provider: PROVIDER$1,
+				siteId: options.siteId,
+				access: siteVisible ? "view" : "noaccess",
+				requiredAccess: "view",
+				errorCode: siteVisible ? void 0 : "MATOMO_ACCESS_DENIED",
+				error: siteVisible ? void 0 : `Token cannot read site ${options.siteId}.`,
+				raw: response
+			};
+		} catch (error) {
+			const errorCode = error instanceof AnalyticsError ? error.code : void 0;
+			return {
+				ok: false,
+				provider: PROVIDER$1,
+				siteId: options.siteId,
+				access: "noaccess",
+				requiredAccess: "view",
+				error: errorCode === "MATOMO_ACCESS_DENIED" ? `Token cannot read site ${options.siteId} (no view grant).` : error instanceof Error ? error.message : String(error),
+				errorCode
+			};
+		}
+	}
+	async mintUserToken(options) {
+		if (!options.passwordConfirmation) throw new AnalyticsError("Matomo's createAppSpecificTokenAuth requires the target user's password as `passwordConfirmation`. (It confirms the user being minted for — not the caller — so a stolen super-user token alone can't mint tokens for arbitrary users.)", "MATOMO_PASSWORD_CONFIRMATION_REQUIRED", PROVIDER$1);
+		const effectiveDescription = options.description ?? `analytics-token ${options.login}`;
+		const response = await this.transport.call("UsersManager.createAppSpecificTokenAuth", {
+			userLogin: options.login,
+			passwordConfirmation: options.passwordConfirmation,
+			description: effectiveDescription,
+			expireHours: 0
+		});
+		const token = isJsonRecord(response) && readString$1(response, "value") || (typeof response === "string" ? response : void 0);
+		if (!token) throw new AnalyticsError("Matomo did not return a token value", "MATOMO_INVALID_RESPONSE", PROVIDER$1);
+		return {
+			token,
+			login: options.login,
+			description: effectiveDescription,
+			provider: PROVIDER$1,
+			raw: response
+		};
+	}
+	async health() {
+		try {
+			const response = await this.transport.call("API.getMatomoVersion", {});
+			return {
+				ok: true,
+				version: isJsonRecord(response) && readString$1(response, "value") || (typeof response === "string" ? response : void 0)
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+};
+function coerceSiteIdResponse(response) {
+	if (typeof response === "number" && Number.isFinite(response)) return String(response);
+	if (typeof response === "string" && response.length > 0) return response;
+	if (isJsonRecord(response)) return readString$1(response, "value") ?? readString$1(response, "idsite") ?? readString$1(response, "idSite");
+}
+function isAccessRole(value) {
+	return value === "noaccess" || value === "view" || value === "write" || value === "admin";
+}
+function normalizeSiteAccessEntries(response) {
+	if (Array.isArray(response)) return response.filter(isJsonRecord).map((row) => {
+		const siteId = readString$1(row, "site") ?? readString$1(row, "idsite") ?? readString$1(row, "idSite");
+		const access = readString$1(row, "access");
+		return siteId && access && isAccessRole(access) ? {
+			siteId,
+			access
+		} : void 0;
+	}).filter((entry) => !!entry);
+	if (isJsonRecord(response)) {
+		const entries = [];
+		for (const [siteId, access] of Object.entries(response)) if (typeof access === "string" && isAccessRole(access)) entries.push({
+			siteId,
+			access
+		});
+		return entries;
+	}
+	return [];
+}
+var ACCESS_RANK = {
+	noaccess: 0,
+	view: 1,
+	write: 2,
+	admin: 3
+};
+function hasMinimumAccess(access, minimumAccess) {
+	return ACCESS_RANK[access] >= ACCESS_RANK[minimumAccess];
+}
+/**
+* Recognise the various ways Matomo signals "this site id doesn't exist (or
+* isn't visible to the caller)". Matomo has at least three error sentinels for
+* this case across versions and contexts:
+*   - "Site not found"
+*   - "doesn't exist" / "does not exist"
+*   - "An unexpected website was found in the request: website id was set to '...'"
+*/
+function isNotFoundSiteError(error) {
+	if (error.code !== "MATOMO_API_ERROR") return false;
+	return /not.*found|doesn'?t exist|does not exist|unknown/i.test(error.message) || /website was found in the request|website id was set/i.test(error.message);
+}
+//#endregion
+//#region src/shared/providers/matomo.ts
+/**
+* Matomo Analytics provider implementation.
+*
+* This first cut implements:
+* - The full `AnalyticsAdminInterface` (sites, users, access, tokens, health)
+*   via {@link MatomoAdmin}. This is the API the tenant doctor uses.
+* - The `AnalyticsInterface` property-management surface, by delegating to the
+*   admin (a Matomo "site" maps 1:1 to a GA4-style "property").
+* - Capabilities, tracking-snippet generation, and a focused reporting surface
+*   for Matomo's VisitsSummary, Actions, Referrers, and Live APIs.
+*
+* GA4-specific concepts that don't translate cleanly (data streams, custom
+* dimensions/metrics, key events, server-side tracking) throw
+* `NotSupportedError`. Matomo has its own analogues (goals, custom dimensions
+* plugin, Tracking HTTP API) — they need a different shape and don't belong on
+* the GA4-shaped methods.
+*/
+var PROVIDER = "matomo";
+var MatomoProvider = class {
+	baseUrl;
+	reportingTransport;
+	admin;
+	constructor(options) {
+		this.baseUrl = normalizeMatomoBaseUrl(options.baseUrl);
+		this.reportingTransport = new MatomoAdminTransport({
+			baseUrl: this.baseUrl,
+			tokenAuth: options.tokenAuth,
+			timeout: options.timeout
+		});
+		this.admin = new MatomoAdmin({
+			baseUrl: this.baseUrl,
+			tokenAuth: options.tokenAuth,
+			timeout: options.timeout
+		});
+	}
+	createProperty(_options) {
+		throw new NotSupportedError("createProperty (use admin.createSite instead)", PROVIDER);
+	}
+	async listProperties(_options) {
+		return (await this.admin.listSites()).map((site) => propertyFromSite(site));
+	}
+	async getProperty(propertyId) {
+		const site = await this.admin.getSite(propertyId);
+		if (!site) throw new PropertyNotFoundError(propertyId, PROVIDER);
+		return propertyFromSite(site);
+	}
+	async updateProperty(_propertyId, _data) {
+		throw new NotSupportedError("updateProperty", PROVIDER);
+	}
+	async deleteProperty(propertyId) {
+		await this.admin.deleteSite(propertyId);
+	}
+	async getCapabilities() {
+		return {
+			propertyManagement: true,
+			dataStreams: false,
+			customDimensions: false,
+			customMetrics: false,
+			keyEvents: false,
+			reporting: true,
+			realtimeReporting: true,
+			serverSideTracking: false,
+			clientSideSnippet: true,
+			userIdentification: false,
+			batchTracking: false
+		};
+	}
+	/**
+	* Generate a Matomo `_paq` tracking snippet.
+	*
+	* Note on `SnippetOptions.anonymizeIp`: Matomo handles IP anonymization
+	* **server-side** via the PrivacyManager plugin (Matomo admin → Privacy →
+	* Anonymize visitors' IP addresses). The JS tracker has no equivalent
+	* client-side directive — `setDoNotTrack` respects the browser's DNT
+	* signal but does not anonymize IPs, so we deliberately do not emit it
+	* here. The flag is preserved on the returned `config` object as a
+	* caller-visible signal, but its enforcement is the operator's
+	* responsibility on the Matomo install.
+	*/
+	generateTrackingSnippet(propertyId, options = {}) {
+		const trackerUrl = `${this.baseUrl}/matomo.php`;
+		const scriptUrl = `${this.baseUrl}/matomo.js`;
+		const sendPageView = options.sendPageView ?? true;
+		const lines = ["var _paq = window._paq = window._paq || [];"];
+		if (sendPageView) lines.push("_paq.push(['trackPageView']);");
+		lines.push("_paq.push(['enableLinkTracking']);");
+		if (options.customConfig) for (const [key, value] of Object.entries(options.customConfig)) lines.push(`_paq.push([${JSON.stringify(key)}, ${JSON.stringify(value)}]);`);
+		lines.push(`(function() { var u=${JSON.stringify(`${this.baseUrl}/`)}; _paq.push(['setTrackerUrl', u+'matomo.php']); _paq.push(['setSiteId', ${JSON.stringify(propertyId)}]); var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0]; g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s); })();`);
+		return {
+			html: `<script>\n${lines.join("\n")}\n<\/script>`,
+			config: {
+				trackerUrl,
+				scriptUrl,
+				siteId: propertyId,
+				anonymizeIp: !!options.anonymizeIp,
+				sendPageView
+			},
+			scripts: [scriptUrl]
+		};
+	}
+	generateConfig(propertyId, options = {}) {
+		return {
+			trackerUrl: `${this.baseUrl}/matomo.php`,
+			scriptUrl: `${this.baseUrl}/matomo.js`,
+			siteId: propertyId,
+			anonymizeIp: !!options.anonymizeIp,
+			sendPageView: options.sendPageView ?? true,
+			userId: options.userId,
+			customDimensions: options.customDimensions
+		};
+	}
+	getDataStreams(_propertyId) {
+		throw new NotSupportedError("dataStreams", PROVIDER);
+	}
+	createDataStream(_propertyId, _options) {
+		throw new NotSupportedError("dataStreams", PROVIDER);
+	}
+	deleteDataStream(_propertyId, _streamId) {
+		throw new NotSupportedError("dataStreams", PROVIDER);
+	}
+	getCustomDimensions(_propertyId) {
+		throw new NotSupportedError("customDimensions", PROVIDER);
+	}
+	createCustomDimension(_propertyId, _options) {
+		throw new NotSupportedError("customDimensions", PROVIDER);
+	}
+	archiveCustomDimension(_propertyId, _dimensionId) {
+		throw new NotSupportedError("customDimensions", PROVIDER);
+	}
+	getCustomMetrics(_propertyId) {
+		throw new NotSupportedError("customMetrics", PROVIDER);
+	}
+	createCustomMetric(_propertyId, _options) {
+		throw new NotSupportedError("customMetrics", PROVIDER);
+	}
+	archiveCustomMetric(_propertyId, _metricId) {
+		throw new NotSupportedError("customMetrics", PROVIDER);
+	}
+	getKeyEvents(_propertyId) {
+		throw new NotSupportedError("keyEvents", PROVIDER);
+	}
+	createKeyEvent(_propertyId, _options) {
+		throw new NotSupportedError("keyEvents", PROVIDER);
+	}
+	deleteKeyEvent(_propertyId, _eventId) {
+		throw new NotSupportedError("keyEvents", PROVIDER);
+	}
+	async runReport(propertyId, options) {
+		const dimensions = options.dimensions ?? [];
+		const metrics = options.metrics;
+		const query = matomoDateQuery(options.dateRanges[0] ?? {
+			startDate: "7daysAgo",
+			endDate: "today"
+		});
+		const dimensionNames = dimensions.map((dimension) => dimension.name);
+		const method = reportMethodForDimensions(dimensionNames);
+		const rows = normalizeMatomoRows(await this.reportingTransport.call(method, {
+			idSite: propertyId,
+			period: method === "VisitsSummary.get" ? "day" : query.period,
+			date: query.date,
+			filter_limit: options.limit,
+			filter_offset: options.offset,
+			flat: dimensionNames.some(isPageDimension) ? 1 : void 0
+		})).map((row) => ({
+			dimensionValues: dimensions.map((dimension) => ({ value: dimensionValue(row, dimension.name) })),
+			metricValues: metrics.map((metric) => ({ value: metricValue(row, metric.name) }))
+		}));
+		return {
+			dimensionHeaders: dimensions.map((dimension) => ({ name: dimension.name })),
+			metricHeaders: metrics.map((metric) => ({
+				name: metric.name,
+				type: metricType(metric.name)
+			})),
+			rows,
+			rowCount: rows.length
+		};
+	}
+	async runRealtimeReport(propertyId, options = {}) {
+		const dimensions = options.dimensions ?? [];
+		const metrics = options.metrics ?? [{ name: "activeUsers" }];
+		const limit = options.limit ?? 10;
+		const lastMinutes = options.minuteRanges?.[0]?.startMinutesAgo ?? 30;
+		if (dimensions.some(isPageDimension)) {
+			const rows = realtimePageRows(await this.reportingTransport.call("Live.getLastVisitsDetails", {
+				idSite: propertyId,
+				period: "day",
+				date: "today",
+				filter_limit: limit,
+				lastMinutes
+			}), dimensions, metrics, limit);
+			return {
+				dimensionHeaders: dimensions.map((dimension) => ({ name: dimension.name })),
+				metricHeaders: metrics.map((metric) => ({
+					name: metric.name,
+					type: metricType(metric.name)
+				})),
+				rows,
+				rowCount: rows.length
+			};
+		}
+		const counters = firstRecord(await this.reportingTransport.call("Live.getCounters", {
+			idSite: propertyId,
+			lastMinutes
+		}));
+		const row = {
+			dimensionValues: dimensions.map((dimension) => ({ value: dimensionValue(counters, dimension.name) })),
+			metricValues: metrics.map((metric) => ({ value: realtimeMetricValue(counters, metric.name) }))
+		};
+		return {
+			dimensionHeaders: dimensions.map((dimension) => ({ name: dimension.name })),
+			metricHeaders: metrics.map((metric) => ({
+				name: metric.name,
+				type: metricType(metric.name)
+			})),
+			rows: [row],
+			rowCount: 1
+		};
+	}
+	getMetrics(_propertyId) {
+		throw new NotSupportedError("getMetrics", PROVIDER);
+	}
+	getDimensions(_propertyId) {
+		throw new NotSupportedError("getDimensions", PROVIDER);
+	}
+	track(_event) {
+		throw new NotSupportedError("track", PROVIDER);
+	}
+	trackPageview(_pageview) {
+		throw new NotSupportedError("trackPageview", PROVIDER);
+	}
+	trackBatch(_events) {
+		throw new NotSupportedError("trackBatch", PROVIDER);
+	}
+	identify(_userId, _traits) {
+		throw new NotSupportedError("identify", PROVIDER);
+	}
+};
+function propertyFromSite(site) {
+	return {
+		id: site.id,
+		name: `sites/${site.id}`,
+		displayName: site.name,
+		createTime: "",
+		timeZone: site.timezone,
+		currencyCode: site.currency
+	};
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function firstRecord(value) {
+	if (Array.isArray(value)) return value.find(isRecord) ?? {};
+	return isRecord(value) ? value : {};
+}
+function normalizeMatomoRows(value) {
+	if (Array.isArray(value)) return value.filter(isRecord);
+	if (!isRecord(value)) return [];
+	const entries = Object.entries(value);
+	if (entries.length > 0 && entries.every(([, row]) => isRecord(row))) return entries.map(([key, row]) => ({
+		...row,
+		date: key
+	}));
+	return [value];
+}
+function matomoDateQuery(range) {
+	if (range.endDate === "today") {
+		const daysAgo = /^(\d+)daysAgo$/.exec(range.startDate);
+		if (daysAgo) return {
+			period: "range",
+			date: `last${daysAgo[1]}`
+		};
+	}
+	if (range.startDate === range.endDate) return {
+		period: "day",
+		date: range.startDate
+	};
+	return {
+		period: "range",
+		date: `${range.startDate},${range.endDate}`
+	};
+}
+function reportMethodForDimensions(dimensions) {
+	if (dimensions.length === 0) return "VisitsSummary.get";
+	if (dimensions.every((dimension) => dimension === "date")) return "VisitsSummary.get";
+	if (dimensions.every(isPageDimension)) return "Actions.getPageUrls";
+	if (dimensions.every((dimension) => dimension === "sessionSource" || dimension === "sessionMedium")) return "Referrers.getAll";
+	throw new NotSupportedError(`Matomo report dimensions (${dimensions.join(", ")})`, PROVIDER);
+}
+function isPageDimension(dimension) {
+	const name = typeof dimension === "string" ? dimension : dimension.name;
+	return [
+		"pagePath",
+		"pageTitle",
+		"unifiedScreenName",
+		"unifiedPagePathScreen"
+	].includes(name);
+}
+function dimensionValue(row, name) {
+	switch (name) {
+		case "date": return readString(row.date) ?? "";
+		case "pagePath":
+		case "unifiedPagePathScreen": return readString(row.url) ?? readString(row.label) ?? "";
+		case "pageTitle":
+		case "unifiedScreenName": return readString(row.pageTitle) ?? readString(row.title) ?? readString(row.label) ?? "";
+		case "sessionSource": return readString(row.label) ?? readString(row.referer_name) ?? readString(row.refererName) ?? "";
+		case "sessionMedium": return readString(row.referer_type) ?? readString(row.refererType) ?? readString(row.type) ?? "";
+		default: return readString(row[name]) ?? "";
+	}
+}
+function metricValue(row, name) {
+	switch (name) {
+		case "activeUsers": return readNumericString(row.nb_uniq_visitors ?? row.nb_users);
+		case "sessions": return readNumericString(row.nb_visits);
+		case "bounceRate": return readNumericString(row.bounce_rate);
+		case "averageSessionDuration": return readNumericString(row.avg_time_on_site);
+		case "screenPageViews": return readNumericString(row.nb_hits ?? row.nb_pageviews);
+		default: return readNumericString(row[name]);
+	}
+}
+function realtimeMetricValue(row, name) {
+	switch (name) {
+		case "activeUsers": return readNumericString(row.visitors ?? row.nb_uniq_visitors);
+		case "sessions": return readNumericString(row.visits ?? row.nb_visits);
+		case "screenPageViews": return readNumericString(row.actions ?? row.nb_hits ?? row.nb_pageviews);
+		default: return metricValue(row, name);
+	}
+}
+function metricType(name) {
+	return name === "bounceRate" ? "TYPE_FLOAT" : "TYPE_INTEGER";
+}
+function readString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+}
+function readNumericString(value) {
+	if (typeof value === "number") return String(value);
+	if (typeof value !== "string") return "0";
+	const trimmed = value.trim();
+	if (!trimmed) return "0";
+	if (trimmed.includes(":")) return String(parseDurationSeconds(trimmed));
+	const numeric = Number(trimmed.replace("%", ""));
+	return Number.isFinite(numeric) ? String(numeric) : "0";
+}
+function parseDurationSeconds(value) {
+	const parts = value.split(":").map((part) => Number(part));
+	if (parts.some((part) => !Number.isFinite(part))) return 0;
+	return parts.reduce((total, part) => total * 60 + part, 0);
+}
+function realtimePageRows(response, dimensions, metrics, limit) {
+	const pageCounts = /* @__PURE__ */ new Map();
+	const visits = normalizeMatomoRows(response);
+	for (const visit of visits) {
+		const visitorId = readString(visit.visitorId) ?? readString(visit.idVisit) ?? "";
+		const actions = Array.isArray(visit.actionDetails) ? visit.actionDetails.filter(isRecord) : [];
+		for (const action of actions) {
+			const title = readString(action.pageTitle) ?? readString(action.title) ?? readString(action.url) ?? "";
+			const url = readString(action.url) ?? title;
+			const key = `${title}\u0000${url}`;
+			const existing = pageCounts.get(key) ?? {
+				pageTitle: title,
+				url,
+				visitors: /* @__PURE__ */ new Set(),
+				actions: 0
+			};
+			existing.actions = Number(existing.actions ?? 0) + 1;
+			if (visitorId) existing.visitors.add(visitorId);
+			pageCounts.set(key, existing);
+		}
+	}
+	return [...pageCounts.values()].sort((a, b) => Number(b.actions ?? 0) - Number(a.actions ?? 0)).slice(0, limit).map((row) => ({
+		dimensionValues: dimensions.map((dimension) => ({ value: dimensionValue(row, dimension.name) })),
+		metricValues: metrics.map((metric) => ({ value: metric.name === "activeUsers" ? String(row.visitors.size) : realtimeMetricValue(row, metric.name) }))
+	}));
+}
+//#endregion
+export { MatomoProvider };
+
+//# sourceMappingURL=matomo-CUUG_Drb.js.map