@happyvertical/analytics 0.74.8

package/dist/chunks/matomo-Ds_oRmZ6.js

@@ -0,0 +1,1043 @@
+import { AnalyticsError, AuthenticationError, NotSupportedError, PropertyNotFoundError } from "../index.js";
+const 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, -"/index.php".length) : value;
+}
+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);
+  }
+  return void 0;
+}
+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;
+  return void 0;
+}
+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";
+}
+class MatomoAdminTransport {
+  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);
+    }
+  }
+}
+const RESERVED_PARAM_KEYS = /* @__PURE__ */ new Set([
+  "module",
+  "method",
+  "format",
+  "token_auth"
+]);
+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
+    );
+  }
+}
+function tryParseJson(text) {
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function mapHttpError(status, body, text) {
+  if (status === 401 || status === 403) {
+    return new AuthenticationError(PROVIDER$1);
+  }
+  const message = isJsonRecord(body) && readString$1(body, "message") || text || `Matomo HTTP ${status}`;
+  return new AnalyticsError(message, `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
+  };
+}
+class MatomoAdmin {
+  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
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Sites
+  // ---------------------------------------------------------------------------
+  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 void 0;
+    } catch (error) {
+      if (error instanceof AnalyticsError && isNotFoundSiteError(error)) {
+        return void 0;
+      }
+      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
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Users
+  // ---------------------------------------------------------------------------
+  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 ?? {}
+    });
+    const user = await this.getUser(options.login);
+    return user ?? {
+      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 void 0;
+    } catch (error) {
+      if (error instanceof AnalyticsError && error.code === "MATOMO_API_ERROR" && /doesn'?t exist|does not exist|unknown/i.test(error.message)) {
+        return void 0;
+      }
+      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 }
+      );
+      const entries = normalizeSiteAccessEntries(response);
+      const match = entries.find((entry) => entry.siteId === options.siteId);
+      let access = match?.access ?? "noaccess";
+      if (access === "noaccess") {
+        const user = await this.getUser(options.login);
+        if (user?.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 transport = this.cloneTransportWithToken(options.tokenAuth);
+      const response = await transport.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
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Health
+  // ---------------------------------------------------------------------------
+  async health() {
+    try {
+      const response = await this.transport.call(
+        "API.getMatomoVersion",
+        {}
+      );
+      const version = isJsonRecord(response) && readString$1(response, "value") || (typeof response === "string" ? response : void 0);
+      return { ok: true, version };
+    } 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");
+  }
+  return void 0;
+}
+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 [];
+}
+const ACCESS_RANK = {
+  noaccess: 0,
+  view: 1,
+  write: 2,
+  admin: 3
+};
+function hasMinimumAccess(access, minimumAccess) {
+  return ACCESS_RANK[access] >= ACCESS_RANK[minimumAccess];
+}
+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);
+}
+const PROVIDER = "matomo";
+class MatomoProvider {
+  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
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Property management — delegated to admin (site === property in Matomo)
+  // ---------------------------------------------------------------------------
+  createProperty(_options) {
+    throw new NotSupportedError(
+      "createProperty (use admin.createSite instead)",
+      PROVIDER
+    );
+  }
+  async listProperties(_options) {
+    const sites = await this.admin.listSites();
+    return sites.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);
+  }
+  // ---------------------------------------------------------------------------
+  // Capabilities
+  // ---------------------------------------------------------------------------
+  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
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Client-side snippet
+  // ---------------------------------------------------------------------------
+  /**
+   * 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>
+${lines.join("\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
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Methods deferred to a follow-up PR — they have meaningful Matomo analogues
+  // but warrant their own tests and a wider review surface.
+  // ---------------------------------------------------------------------------
+  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 dateRange = options.dateRanges[0] ?? {
+      startDate: "7daysAgo",
+      endDate: "today"
+    };
+    const query = matomoDateQuery(dateRange);
+    const dimensionNames = dimensions.map((dimension) => dimension.name);
+    const method = reportMethodForDimensions(dimensionNames);
+    const response = 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
+    });
+    const sourceRows = normalizeMatomoRows(response);
+    const rows = sourceRows.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 response2 = await this.reportingTransport.call(
+        "Live.getLastVisitsDetails",
+        {
+          idSite: propertyId,
+          period: "day",
+          date: "today",
+          filter_limit: limit,
+          lastMinutes
+        }
+      );
+      const rows = realtimePageRows(response2, 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 response = await this.reportingTransport.call(
+      "Live.getCounters",
+      {
+        idSite: propertyId,
+        lastMinutes
+      }
+    );
+    const counters = firstRecord(response);
+    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);
+  return void 0;
+}
+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}\0${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)
+    }))
+  }));
+}
+export {
+  MatomoProvider
+};
+//# sourceMappingURL=matomo-Ds_oRmZ6.js.map